Release/v0.2.2 (#258)

* 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * Fix/interface home (#182) * [fix]Fix the interface for statistics of recent activities and applications * [changes]Modify the code based on the AI review 1.Use the boolean auxiliary methods provided by SQLAlchemy instead of using == True in the is_active filter. 2.The calculation of the "PROJECT_ROOT" has now been hardcoded with five levels of nested os.path.dirname calls. * [fix]Fix the interface for statistics of recent activities and applications * [changes]Modify the code based on the AI review 1.Use the boolean auxiliary methods provided by SQLAlchemy instead of using == True in the is_active filter. 2.The calculation of the "PROJECT_ROOT" has now been hardcoded with five levels of nested os.path.dirname calls. * Fix/optimize inerface (#183) * [changes]Optimize the time consumption of the "/end_users" interface * [fix]Optimize the time consumption of the "/hot_memory_tags" interface * [changes]Optimize the time consumption of the "/end_users" interface * [fix]Optimize the time consumption of the "/hot_memory_tags" interface * [changes]Improve the code based on AI review * Fix/memory mcp2 1 (#184) * 优化快速检索的回复内容 * 优化快速检索的回复内容 * Fix/memory mcp2 1 (#185) * 优化快速检索的回复内容 * 优化快速检索的回复内容 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * Fix/memory mcp2 1 (#188) * 优化快速检索的回复内容 * 优化快速检索的回复内容 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * LLM生存缺少config_id认证，修复BUG * LLM生存缺少config_id认证，修复BUG * LLM生存缺少config_id认证，修复BUG * 解决冲突 * 解决冲突 * feat(home page): version description update * Fix/memory mcp2 1 (#190) * 优化快速检索的回复内容 * 优化快速检索的回复内容 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * 路径的BUG修复 * LLM生存缺少config_id认证，修复BUG * LLM生存缺少config_id认证，修复BUG * LLM生存缺少config_id认证，修复BUG * 深度检索优化，搜索不到数据/提问的概念过于蘑菇，以引导的方式继续提问 * 深度检索优化，搜索不到数据/提问的概念过于蘑菇，以引导的方式继续提问 * 深度检索优化，搜索不到数据/提问的概念过于蘑菇，以引导的方式继续提问 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * feat(web): memory related interface parameter transfer adjustment * 感知meta_data字段BUG修复 * Fix/memory bug fix (#171) * feat(sandbox): add Python 3 code execution sandbox support * feat(workflow): emit SSE events for node exception output * perf(sandbox): optimize code encryption handling * perf(workflow): update standard node output structure * [add] migration script * [modify] migration script * feat(web): add workflow runtime info * fix(web): handleSSE bugfix * fix(sandbox): prevent imports from being blocked when network is disabled * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * Fix/memory bug fix (#199) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 --------- Co-authored-by: lanceyq <1982376970@qq.com> * user_id->显示为config_id_old传输 * feat(web): update read_all_config select valueKey * user_id->显示为config_id_old传输 * feat(workflow): Add a new node for executing code * fix(web): KnowledgeConfigModal bugfix * fix(web): iteration's variable add parameter-extractor node * fix(sandbox): treat non-zero exit codes as errors instead of relying only on stderr * Fix/memory bug fix (#200) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 --------- Co-authored-by: lanceyq <1982376970@qq.com> * Refactor/benchmark test (#196) * [changes]refactor locomo_test * [fix]Fix the circular import of ModelParameters * [changes]The benchmark test can run stably. * [fix]Complete end-to-end LoCoMo repair * [fix]Complete the end-to-end longmemeval and memsciqa fixes * [changes]Complete the benchmark test description document to ensure that the configuration parameters take effect. * [changes]refactor locomo_test * [fix]Fix the circular import of ModelParameters * [changes]The benchmark test can run stably. * [fix]Complete end-to-end LoCoMo repair * [fix]Complete the end-to-end longmemeval and memsciqa fixes * [changes]Complete the benchmark test description document to ensure that the configuration parameters take effect. * [changes]Benchmark test adaptation for end_user_id * [changes]refactor locomo_test * [fix]Fix the circular import of ModelParameters * [changes]The benchmark test can run stably. * [fix]Complete end-to-end LoCoMo repair * [fix]Complete the end-to-end longmemeval and memsciqa fixes * [changes]Complete the benchmark test description document to ensure that the configuration parameters take effect. * [fix]Complete the end-to-end longmemeval and memsciqa fixes * [changes]Complete the benchmark test description document to ensure that the configuration parameters take effect. * [changes]Benchmark test adaptation for end_user_id * [modify] migration script * delete benchmark-test (#204) * Refactor: Move evaluation folder to redbear-mem-benchmark submodule * [changes]Restore .gitmodules * feat(web): workflow add code node * 检查需要更改的格式问题 * Fix/redbear benchmark (#205) * Refactor: Move evaluation folder to redbear-mem-benchmark submodule * [changes]Update submodule reference * Refactor: Move evaluation folder to redbear-mem-benchmark submodule * [changes]Update submodule reference * Remove duplicate evaluation submodule, use redbear-mem-benchmark instead * Fix/memory bug fix (#207) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * 检查需要更改的格式问题 --------- Co-authored-by: lanceyq <1982376970@qq.com> * fix(web): remove URI decode and encode * [add] plugin system and base sso module * 修复宿主列表获取memory_config_idBUG * Fix/memory bug fix (#209) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * 检查需要更改的格式问题 * 修复宿主列表获取memory_config_idBUG --------- Co-authored-by: lanceyq <1982376970@qq.com> * [modify] file local server url * [add] migration script * fix(workflow): fix activation and branch control issues in streaming output * fix(workflow): fix function cache not taking effect and potential list index overflow * style(workflow): enforce PEP8 style and remove redundant imports * fix(workflow): fix streaming output error when variable is not a string * [fix]remove aspose-slides * perf(workflow): enhance streaming output node activation performance * feat(workflow): store token usage in message table * feat(web): add PageEmpty component * feat(web): add PageTabs component * perf(workflow): make memory configuration backward compatible * feat(web): update model management * config_id做映射 * config_id做映射 * Fix/memory bug fix (#211) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * 检查需要更改的格式问题 * 修复宿主列表获取memory_config_idBUG * config_id做映射 * config_id做映射 --------- Co-authored-by: lanceyq <1982376970@qq.com> * feat(web): getModelListUrl add is_active param * config_id做映射+1 * config_id做映射+1 * config_id做映射+1 * feat(web): remove file url replace * Fix/memory bug fix (#212) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * 检查需要更改的格式问题 * 修复宿主列表获取memory_config_idBUG * config_id做映射 * config_id做映射 * config_id做映射+1 * config_id做映射+1 * config_id做映射+1 --------- Co-authored-by: lanceyq <1982376970@qq.com> * feat(model and app statistic): 1. Optimize the model list; 2. Increase the model combination; 3. Add a model square; 4. Add application management statistics * feat(web): model logo update * 应用层memory_content->memory_config * fix(web): correct spelling * 应用层memory_content->memory_config * 应用层memory_content->memory_config * Fix/memory bug fix (#215) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * 检查需要更改的格式问题 * 修复宿主列表获取memory_config_idBUG * config_id做映射 * config_id做映射 * config_id做映射+1 * config_id做映射+1 * config_id做映射+1 * 应用层memory_content->memory_config * 应用层memory_content->memory_config * 应用层memory_content->memory_config --------- Co-authored-by: lanceyq <1982376970@qq.com> * feat(model and app statistic): 1. Optimize the model list; 2. Increase the model combination; 3. Add a model square; 4. Add application management statistics * fix(web): model loading update * 统一字段为config_id_old * 统一字段为config_id_old * feat(model and app statistic): 1. Optimize the model list; 2. Increase the model combination; 3. Add a model square; 4. Add application management statistics * 统一字段为config_id_old * 统一字段为config_id_old * memory_content暂时不修改 * memory_content暂时不修改 * Fix/memory bug fix (#217) * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 图谱数据量限制数量去掉 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 用户详情优化 * 读取的接口，去掉全局锁 * 输出数组 * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化1.0（优化隐私输出、时间检索） * 反思优化测试接口 * 反思优化测试接口 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 读取接口内层嵌套BUG修复 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察) * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 新增中翻英功能（记忆时间线）(用户摘要)(兴趣分布接口)(查询核心档案)(记忆洞察)-接口添加翻译字段 * 把group_id替换end_user_id * 把group_id替换end_user_id_ * 把group_id替换end_user_id_ * config_config替换成memory_config * config_config替换成memory_config * [fix]Fix the memory interface to use end_user_id. * config_config替换成memory_config * config_config替换成memory_config * config_config替换成memory_config * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID * config_id字段改成UUID，与develop校对恢复 * 检查项目，修复group_id的遗留问题 * 检查项目，修复group_id的遗留问题 * 解决冲突 * 解决冲突 * end_user_id清理干净 * end_user_id清理干净 * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 修复遗留合并BUG * 感知meta_data字段BUG修复 * user_id->现实为config_id_old * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * user_id->显示为config_id_old传输 * 检查需要更改的格式问题 * 修复宿主列表获取memory_config_idBUG * config_id做映射 * config_id做映射 * config_id做映射+1 * config_id做映射+1 * config_id做映射+1 * 应用层memory_content->memory_config * 应用层memory_content->memory_config * 应用层memory_content->memory_config * 统一字段为config_id_old * 统一字段为config_id_old * 统一字段为config_id_old * 统一字段为config_id_old * memory_content暂时不修改 * memory_content暂时不修改 --------- Co-authored-by: lanceyq <1982376970@qq.com> * feat(web): add app statistics * fix(workflow): fix streaming output issues with multi-output End nodes End nodes with multiple output segments could cause cursor errors or leave some segments inactive, resulting in incorrect final outputs. Unified _emit_active_chunks and _update_scope_activate to ensure all segments are activated in order and streamed correctly. * feat(web): add apps statistics api * fix(web): agent's knowledge_bases bugfix * Revert "feat(web): update read_all_config select valueKey" This reverts commit 46f0f3cee9. * [add] migrations script * perf(workflow): make memory write node backward-compatible and defer config validation * 旧数据兼容 * 旧数据兼容 * 旧数据兼容 * 旧数据兼容 * fix(web): model bugfix * fix(web): model bugfix * 提交遗漏 (#228) * [fix] chat api for workflow * [fix] web search set for v1 api * fix(web): model bugfix * fix(web): model list remove is_active * fix(model): bug fix * [add]migration script * [fix] api * [fix] api * fix(web): model bugfix * fix(model): the model type does not allow modification, delete tts and speech2text type * fix(model): bug fix * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * Add/develop memory (#239) * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * feat(web): model ui update * feat(web): model ui update * Add/develop memory (#243) * 遗漏的历史映射 * 遗漏的历史映射 * fix(model): bug fix * feat(web): model ui update * Add/develop memory (#247) * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * 遗漏的历史映射 * [modify] migration script * [add] migration script * fix(web): change form message * fix(web): the memoryContent field is compatible with numbers and strings * feat(web): code node hidden * fix(model): 1. create a basic model to check if the name and provider are duplicated. 2. The result shows error models because the provider created API Keys for all matching models. --------- Co-authored-by: lixinyue <2569494688@qq.com> Co-authored-by: lanceyq <1982376970@qq.com> Co-authored-by: yujiangping <yujiangping@taofen8.com> Co-authored-by: 乐力齐 <162269739+lanceyq@users.noreply.github.com> Co-authored-by: lixinyue11 <94037597+lixinyue11@users.noreply.github.com> Co-authored-by: yingzhao <zhaoyingyz@126.com> Co-authored-by: Timebomb2018 <18868801967@163.com> Co-authored-by: Mark <zhuwenhui5566@163.com> Co-authored-by: zhaoying <yzhao96@best-inc.com> Co-authored-by: Eternity <1533512157@qq.com> Co-authored-by: lixiangcheng1 <lixiangcheng1@wanda.cn>
2026-01-30 14:51:34 +08:00
parent 988a41f5e4
commit 0159fdf149
320 changed files with 11769 additions and 11942 deletions
--- a/api/app/controllers/app_controller.py
+++ b/api/app/controllers/app_controller.py
@@ -872,3 +872,44 @@ async def update_workflow_config(
    workspace_id = current_user.current_workspace_id
    cfg = app_service.update_workflow_config(db, app_id=app_id, data=payload, workspace_id=workspace_id)
    return success(data=WorkflowConfigSchema.model_validate(cfg))
+
+
+@router.get("/{app_id}/statistics", summary="应用统计数据")
+@cur_workspace_access_guard()
+def get_app_statistics(
+        app_id: uuid.UUID,
+        start_date: int,
+        end_date: int,
+        db: Session = Depends(get_db),
+        current_user=Depends(get_current_user),
+):
+    """获取应用统计数据
+    
+    Args:
+        app_id: 应用ID
+        start_date: 开始时间戳（毫秒）
+        end_date: 结束时间戳（毫秒）
+    
+    Returns:
+        - daily_conversations: 每日会话数统计
+        - total_conversations: 总会话数
+        - daily_new_users: 每日新增用户数
+        - total_new_users: 总新增用户数
+        - daily_api_calls: 每日API调用次数
+        - total_api_calls: 总API调用次数
+        - daily_tokens: 每日token消耗
+        - total_tokens: 总token消耗
+    """
+    workspace_id = current_user.current_workspace_id
+    
+    from app.services.app_statistics_service import AppStatisticsService
+    stats_service = AppStatisticsService(db)
+    
+    result = stats_service.get_app_statistics(
+        app_id=app_id,
+        workspace_id=workspace_id,
+        start_date=start_date,
+        end_date=end_date
+    )
+    
+    return success(data=result)
--- a/api/app/controllers/emotion_config_controller.py
+++ b/api/app/controllers/emotion_config_controller.py
@@ -7,11 +7,13 @@ Routes:
    GET /memory/config/emotion - 获取情绪引擎配置
    POST /memory/config/emotion - 更新情绪引擎配置
 """
+import uuid

 from fastapi import APIRouter, Depends, Query, HTTPException, status
 from pydantic import BaseModel, Field
-from typing import Optional
+from typing import Optional, Union
 from sqlalchemy.orm import Session
+from uuid import UUID

 from app.core.response_utils import success
 from app.dependencies import get_current_user
@@ -20,6 +22,7 @@ from app.schemas.response_schema import ApiResponse
 from app.services.emotion_config_service import EmotionConfigService
 from app.core.logging_config import get_api_logger
 from app.db import get_db
+from app.utils.config_utils import resolve_config_id

 # 获取API专用日志器
 api_logger = get_api_logger()
@@ -32,11 +35,11 @@ router = APIRouter(

 class EmotionConfigQuery(BaseModel):
    """情绪配置查询请求模型"""
-    config_id: int = Field(..., description="配置ID")
+    config_id: UUID = Field(..., description="配置ID")

 class EmotionConfigUpdate(BaseModel):
    """情绪配置更新请求模型"""
-    config_id: int = Field(..., description="配置ID")
+    config_id: Union[uuid.UUID, int, str]= Field(..., description="配置ID")
    emotion_enabled: bool = Field(..., description="是否启用情绪提取")
    emotion_model_id: Optional[str] = Field(None, description="情绪分析专用模型ID")
    emotion_extract_keywords: bool = Field(..., description="是否提取情绪关键词")
@@ -45,7 +48,7 @@ class EmotionConfigUpdate(BaseModel):

@router.get("/read_config", response_model=ApiResponse)
 def get_emotion_config(
-    config_id: int = Query(..., description="配置ID"),
+    config_id: UUID|int = Query(..., description="配置ID"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
 ):
@@ -78,7 +81,7 @@ def get_emotion_config(
            f"用户 {current_user.username} 请求获取情绪配置",
            extra={"config_id": config_id}
        )
-        
+        config_id=resolve_config_id(config_id, db)
        # 初始化服务
        config_service = EmotionConfigService(db)
        
@@ -157,6 +160,7 @@ def update_emotion_config(
            }
        }
    """
+    config.config_id=resolve_config_id(config.config_id, db)
    try:
        api_logger.info(
            f"用户 {current_user.username} 请求更新情绪配置",
--- a/api/app/controllers/emotion_controller.py
+++ b/api/app/controllers/emotion_controller.py
@@ -53,7 +53,7 @@ async def get_emotion_tags(
        api_logger.info(
            f"用户 {current_user.username} 请求获取情绪标签统计",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "emotion_type": request.emotion_type,
                "start_date": request.start_date,
                "end_date": request.end_date,
@@ -63,7 +63,7 @@ async def get_emotion_tags(

        # 调用服务层
        data = await emotion_service.get_emotion_tags(
-            end_user_id=request.group_id,
+            end_user_id=request.end_user_id,
            emotion_type=request.emotion_type,
            start_date=request.start_date,
            end_date=request.end_date,
@@ -73,7 +73,7 @@ async def get_emotion_tags(
        api_logger.info(
            "情绪标签统计获取成功",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "total_count": data.get("total_count", 0),
                "tags_count": len(data.get("tags", []))
            }
@@ -84,7 +84,7 @@ async def get_emotion_tags(
    except Exception as e:
        api_logger.error(
            f"获取情绪标签统计失败: {str(e)}",
-            extra={"group_id": request.group_id},
+            extra={"end_user_id": request.end_user_id},
            exc_info=True
        )
        raise HTTPException(
@@ -105,7 +105,7 @@ async def get_emotion_wordcloud(
        api_logger.info(
            f"用户 {current_user.username} 请求获取情绪词云数据",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "emotion_type": request.emotion_type,
                "limit": request.limit
            }
@@ -113,7 +113,7 @@ async def get_emotion_wordcloud(

        # 调用服务层
        data = await emotion_service.get_emotion_wordcloud(
-            end_user_id=request.group_id,
+            end_user_id=request.end_user_id,
            emotion_type=request.emotion_type,
            limit=request.limit
        )
@@ -121,7 +121,7 @@ async def get_emotion_wordcloud(
        api_logger.info(
            "情绪词云数据获取成功",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "total_keywords": data.get("total_keywords", 0)
            }
        )
@@ -131,7 +131,7 @@ async def get_emotion_wordcloud(
    except Exception as e:
        api_logger.error(
            f"获取情绪词云数据失败: {str(e)}",
-            extra={"group_id": request.group_id},
+            extra={"end_user_id": request.end_user_id},
            exc_info=True
        )
        raise HTTPException(
@@ -159,21 +159,21 @@ async def get_emotion_health(
        api_logger.info(
            f"用户 {current_user.username} 请求获取情绪健康指数",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "time_range": request.time_range
            }
        )

        # 调用服务层
        data = await emotion_service.calculate_emotion_health_index(
-            end_user_id=request.group_id,
+            end_user_id=request.end_user_id,
            time_range=request.time_range
        )

        api_logger.info(
            "情绪健康指数获取成功",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "health_score": data.get("health_score", 0),
                "level": data.get("level", "未知")
            }
@@ -186,7 +186,7 @@ async def get_emotion_health(
    except Exception as e:
        api_logger.error(
            f"获取情绪健康指数失败: {str(e)}",
-            extra={"group_id": request.group_id},
+            extra={"end_user_id": request.end_user_id},
            exc_info=True
        )
        raise HTTPException(
@@ -206,7 +206,7 @@ async def get_emotion_suggestions(
    """获取个性化情绪建议（从缓存读取）

    Args:
-        request: 包含 group_id 和可选的 config_id
+        request: 包含 end_user_id 和可选的 config_id
        db: 数据库会话
        current_user: 当前用户

@@ -217,22 +217,22 @@ async def get_emotion_suggestions(
        api_logger.info(
            f"用户 {current_user.username} 请求获取个性化情绪建议（缓存）",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "config_id": request.config_id
            }
        )

        # 从缓存获取建议
        data = await emotion_service.get_cached_suggestions(
-            end_user_id=request.group_id,
+            end_user_id=request.end_user_id,
            db=db
        )

        if data is None:
            # 缓存不存在或已过期
            api_logger.info(
-                f"用户 {request.group_id} 的建议缓存不存在或已过期",
-                extra={"group_id": request.group_id}
+                f"用户 {request.end_user_id} 的建议缓存不存在或已过期",
+                extra={"end_user_id": request.end_user_id}
            )
            return fail(
                BizCode.NOT_FOUND,
@@ -243,7 +243,7 @@ async def get_emotion_suggestions(
        api_logger.info(
            "个性化建议获取成功（缓存）",
            extra={
-                "group_id": request.group_id,
+                "end_user_id": request.end_user_id,
                "suggestions_count": len(data.get("suggestions", []))
            }
        )
@@ -253,7 +253,7 @@ async def get_emotion_suggestions(
    except Exception as e:
        api_logger.error(
            f"获取个性化建议失败: {str(e)}",
-            extra={"group_id": request.group_id},
+            extra={"end_user_id": request.end_user_id},
            exc_info=True
        )
        raise HTTPException(
--- a/api/app/controllers/file_storage_controller.py
+++ b/api/app/controllers/file_storage_controller.py
@@ -310,7 +310,7 @@ async def get_file_url(
    try:
        if permanent:
            # Generate permanent URL (no expiration check)
-            server_url = f"http://{settings.SERVER_IP}:8000/api"
+            server_url = settings.FILE_LOCAL_SERVER_URL
            url = f"{server_url}/storage/permanent/{file_id}"
            return success(
                data={
--- a/api/app/controllers/implicit_memory_controller.py
+++ b/api/app/controllers/implicit_memory_controller.py
@@ -122,10 +122,10 @@ def validate_confidence_threshold(threshold: float) -> None:
        raise ValueError("confidence_threshold must be between 0.0 and 1.0")


-@router.get("/preferences/{user_id}", response_model=ApiResponse)
+@router.get("/preferences/{end_user_id}", response_model=ApiResponse)
@cur_workspace_access_guard()
 async def get_preference_tags(
-    user_id: str,
+    end_user_id: str,
    confidence_threshold: float = Query(0.5, ge=0.0, le=1.0, description="Minimum confidence threshold"),
    tag_category: Optional[str] = Query(None, description="Filter by tag category"),
    start_date: Optional[datetime] = Query(None, description="Filter start date"),
@@ -137,7 +137,7 @@ async def get_preference_tags(
    Get user preference tags from cache.
    
    Args:
-        user_id: Target user ID
+        end_user_id: Target end user ID
        confidence_threshold: Minimum confidence score (0.0-1.0)
        tag_category: Optional category filter
        start_date: Optional start date filter
@@ -146,20 +146,20 @@ async def get_preference_tags(
    Returns:
        List of preference tags from cache
    """
-    api_logger.info(f"Preference tags requested for user: {user_id} (from cache)")
+    api_logger.info(f"Preference tags requested for user: {end_user_id} (from cache)")
    
    try:
        # Validate inputs
-        validate_user_id(user_id)
+        validate_user_id(end_user_id)
        
        # Create service with user-specific config
-        service = ImplicitMemoryService(db=db, end_user_id=user_id)
+        service = ImplicitMemoryService(db=db, end_user_id=end_user_id)
        
        # Get cached profile
-        cached_profile = await service.get_cached_profile(end_user_id=user_id, db=db)
+        cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
        
        if cached_profile is None:
-            api_logger.info(f"用户 {user_id} 的画像缓存不存在或已过期")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
            return fail(
                BizCode.NOT_FOUND,
                "画像缓存不存在或已过期，请右上角刷新生成新画像",
@@ -192,17 +192,17 @@ async def get_preference_tags(
            
            filtered_preferences.append(pref)
        
-        api_logger.info(f"Retrieved {len(filtered_preferences)} preference tags for user: {user_id} (from cache)")
+        api_logger.info(f"Retrieved {len(filtered_preferences)} preference tags for user: {end_user_id} (from cache)")
        return success(data=filtered_preferences, msg="偏好标签获取成功（缓存）")
        
    except Exception as e:
-        return handle_implicit_memory_error(e, "偏好标签获取", user_id)
+        return handle_implicit_memory_error(e, "偏好标签获取", end_user_id)


-@router.get("/portrait/{user_id}", response_model=ApiResponse)
+@router.get("/portrait/{end_user_id}", response_model=ApiResponse)
@cur_workspace_access_guard()
 async def get_dimension_portrait(
-    user_id: str,
+    end_user_id: str,
    include_history: bool = Query(False, description="Include historical trends"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
@@ -211,26 +211,26 @@ async def get_dimension_portrait(
    Get user's four-dimension personality portrait from cache.
    
    Args:
-        user_id: Target user ID
+        end_user_id: Target end user ID
        include_history: Whether to include historical trend data (ignored for cached data)
        
    Returns:
        Four-dimension personality portrait from cache
    """
-    api_logger.info(f"Dimension portrait requested for user: {user_id} (from cache)")
+    api_logger.info(f"Dimension portrait requested for user: {end_user_id} (from cache)")
    
    try:
        # Validate inputs
-        validate_user_id(user_id)
+        validate_user_id(end_user_id)
        
        # Create service with user-specific config
-        service = ImplicitMemoryService(db=db, end_user_id=user_id)
+        service = ImplicitMemoryService(db=db, end_user_id=end_user_id)
        
        # Get cached profile
-        cached_profile = await service.get_cached_profile(end_user_id=user_id, db=db)
+        cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
        
        if cached_profile is None:
-            api_logger.info(f"用户 {user_id} 的画像缓存不存在或已过期")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
            return fail(
                BizCode.NOT_FOUND,
                "画像缓存不存在或已过期，请右上角刷新生成新画像",
@@ -240,17 +240,17 @@ async def get_dimension_portrait(
        # Extract portrait from cache
        portrait = cached_profile.get("portrait", {})
        
-        api_logger.info(f"Dimension portrait retrieved for user: {user_id} (from cache)")
+        api_logger.info(f"Dimension portrait retrieved for user: {end_user_id} (from cache)")
        return success(data=portrait, msg="四维画像获取成功（缓存）")
        
    except Exception as e:
-        return handle_implicit_memory_error(e, "四维画像获取", user_id)
+        return handle_implicit_memory_error(e, "四维画像获取", end_user_id)


-@router.get("/interest-areas/{user_id}", response_model=ApiResponse)
+@router.get("/interest-areas/{end_user_id}", response_model=ApiResponse)
@cur_workspace_access_guard()
 async def get_interest_area_distribution(
-    user_id: str,
+    end_user_id: str,
    include_trends: bool = Query(False, description="Include trend analysis"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
@@ -259,26 +259,26 @@ async def get_interest_area_distribution(
    Get user's interest area distribution from cache.
    
    Args:
-        user_id: Target user ID
+        end_user_id: Target end user ID
        include_trends: Whether to include trend analysis data (ignored for cached data)
        
    Returns:
        Interest area distribution from cache
    """
-    api_logger.info(f"Interest area distribution requested for user: {user_id} (from cache)")
+    api_logger.info(f"Interest area distribution requested for user: {end_user_id} (from cache)")
    
    try:
        # Validate inputs
-        validate_user_id(user_id)
+        validate_user_id(end_user_id)
        
        # Create service with user-specific config
-        service = ImplicitMemoryService(db=db, end_user_id=user_id)
+        service = ImplicitMemoryService(db=db, end_user_id=end_user_id)
        
        # Get cached profile
-        cached_profile = await service.get_cached_profile(end_user_id=user_id, db=db)
+        cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
        
        if cached_profile is None:
-            api_logger.info(f"用户 {user_id} 的画像缓存不存在或已过期")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
            return fail(
                BizCode.NOT_FOUND,
                "画像缓存不存在或已过期，请右上角刷新生成新画像",
@@ -288,17 +288,17 @@ async def get_interest_area_distribution(
        # Extract interest areas from cache
        interest_areas = cached_profile.get("interest_areas", {})
        
-        api_logger.info(f"Interest area distribution retrieved for user: {user_id} (from cache)")
+        api_logger.info(f"Interest area distribution retrieved for user: {end_user_id} (from cache)")
        return success(data=interest_areas, msg="兴趣领域分布获取成功（缓存）")
        
    except Exception as e:
-        return handle_implicit_memory_error(e, "兴趣领域分布获取", user_id)
+        return handle_implicit_memory_error(e, "兴趣领域分布获取", end_user_id)


-@router.get("/habits/{user_id}", response_model=ApiResponse)
+@router.get("/habits/{end_user_id}", response_model=ApiResponse)
@cur_workspace_access_guard()
 async def get_behavior_habits(
-    user_id: str,
+    end_user_id: str,
    confidence_level: Optional[str] = Query(None, regex="^(high|medium|low)$", description="Filter by confidence level"),
    frequency_pattern: Optional[str] = Query(None, regex="^(daily|weekly|monthly|seasonal|occasional|event_triggered)$", description="Filter by frequency pattern"),
    time_period: Optional[str] = Query(None, regex="^(current|past)$", description="Filter by time period"),
@@ -309,7 +309,7 @@ async def get_behavior_habits(
    Get user's behavioral habits from cache.
    
    Args:
-        user_id: Target user ID
+        end_user_id: Target end user ID
        confidence_level: Filter by confidence level (high, medium, low)
        frequency_pattern: Filter by frequency pattern (daily, weekly, monthly, seasonal, occasional, event_triggered)
        time_period: Filter by time period (current, past)
@@ -317,20 +317,20 @@ async def get_behavior_habits(
    Returns:
        List of behavioral habits from cache
    """
-    api_logger.info(f"Behavior habits requested for user: {user_id} (from cache)")
+    api_logger.info(f"Behavior habits requested for user: {end_user_id} (from cache)")
    
    try:
        # Validate inputs
-        validate_user_id(user_id)
+        validate_user_id(end_user_id)
        
        # Create service with user-specific config
-        service = ImplicitMemoryService(db=db, end_user_id=user_id)
+        service = ImplicitMemoryService(db=db, end_user_id=end_user_id)
        
        # Get cached profile
-        cached_profile = await service.get_cached_profile(end_user_id=user_id, db=db)
+        cached_profile = await service.get_cached_profile(end_user_id=end_user_id, db=db)
        
        if cached_profile is None:
-            api_logger.info(f"用户 {user_id} 的画像缓存不存在或已过期")
+            api_logger.info(f"用户 {end_user_id} 的画像缓存不存在或已过期")
            return fail(
                BizCode.NOT_FOUND,
                "画像缓存不存在或已过期，请右上角刷新生成新画像",
@@ -368,11 +368,11 @@ async def get_behavior_habits(
            
            filtered_habits.append(habit)
        
-        api_logger.info(f"Retrieved {len(filtered_habits)} behavior habits for user: {user_id} (from cache)")
+        api_logger.info(f"Retrieved {len(filtered_habits)} behavior habits for user: {end_user_id} (from cache)")
        return success(data=filtered_habits, msg="行为习惯获取成功（缓存）")
        
    except Exception as e:
-        return handle_implicit_memory_error(e, "行为习惯获取", user_id)
+        return handle_implicit_memory_error(e, "行为习惯获取", end_user_id)



--- a/api/app/controllers/memory_agent_controller.py
+++ b/api/app/controllers/memory_agent_controller.py
@@ -125,7 +125,7 @@ async def write_server(
    Write service endpoint - processes write operations synchronously
    
    Args:
-        user_input: Write request containing message and group_id
+        user_input: Write request containing message and end_user_id
    
    Returns:
        Response with write operation status
@@ -160,19 +160,18 @@ async def write_server(
            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}")
+    api_logger.info(f"Write service requested for group {user_input.end_user_id}, storage_type: {storage_type}, user_rag_memory_id: {user_rag_memory_id}")
    try:
-        # 获取标准化的消息列表
        messages_list = memory_agent_service.get_messages_list(user_input)
-        
        result = await memory_agent_service.write_memory(
-            user_input.group_id, 
-            messages_list,  # 传递结构化消息列表
+            user_input.end_user_id,
+            messages_list,
            config_id,
            db,
            storage_type, 
            user_rag_memory_id
        )
+
        return success(data=result, msg="写入成功")
    except BaseException as e:
        # Handle ExceptionGroup from TaskGroup (Python 3.11+) or BaseExceptionGroup
@@ -196,7 +195,7 @@ async def write_server_async(
    Async write service endpoint - enqueues write processing to Celery
    
    Args:
-        user_input: Write request containing message and group_id
+        user_input: Write request containing message and end_user_id
    
    Returns:
        Task ID for tracking async operation
@@ -226,10 +225,10 @@ async def write_server_async(
    try:
        # 获取标准化的消息列表
        messages_list = memory_agent_service.get_messages_list(user_input)
-        
+
        task = celery_app.send_task(
            "app.core.memory.agent.write_message",
-            args=[user_input.group_id, messages_list, config_id, storage_type, user_rag_memory_id]
+            args=[user_input.end_user_id, messages_list, config_id, storage_type, user_rag_memory_id]
        )
        api_logger.info(f"Write task queued: {task.id}")
        
@@ -255,16 +254,14 @@ async def read_server(
    - "2": Direct answer based on context
    
    Args:
-        user_input: Read request with message, history, search_switch, and group_id
+        user_input: Read request with message, history, search_switch, and end_user_id
    
    Returns:
        Response with query answer
    """
    config_id = user_input.config_id
    workspace_id = current_user.current_workspace_id
-    api_logger.info(f"Read service: workspace_id={workspace_id}, config_id={config_id}")

-    # 获取 storage_type，如果为 None 则使用默认值
    storage_type = workspace_service.get_workspace_storage_type(
        db=db,
        workspace_id=workspace_id,
@@ -279,12 +276,13 @@ async def read_server(
            name="USER_RAG_MERORY",
            workspace_id=workspace_id
        )
-        if knowledge: user_rag_memory_id = str(knowledge.id)
+        if knowledge:
+            user_rag_memory_id = str(knowledge.id)
    
-    api_logger.info(f"Read service: group={user_input.group_id}, storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}, workspace_id={workspace_id}")
+    api_logger.info(f"Read service: group={user_input.end_user_id}, storage_type={storage_type}, user_rag_memory_id={user_rag_memory_id}, workspace_id={workspace_id}")
    try:
        result = await memory_agent_service.read_memory(
-            user_input.group_id,
+            user_input.end_user_id,
            user_input.message,
            user_input.history,
            user_input.search_switch,
@@ -295,17 +293,20 @@ async def read_server(
        )
        if str(user_input.search_switch) == "2":
            retrieve_info = result['answer']
-            history = await SessionService(store).get_history(user_input.group_id, user_input.group_id, user_input.group_id)
+            history = await SessionService(store).get_history(user_input.end_user_id, user_input.end_user_id, user_input.end_user_id)
            query = user_input.message
-            
+
            # 调用 memory_agent_service 的方法生成最终答案
            result['answer'] = await memory_agent_service.generate_summary_from_retrieve(
+                end_user_id=user_input.end_user_id,
                retrieve_info=retrieve_info,
                history=history,
                query=query,
                config_id=config_id,
                db=db
            )
+            if "信息不足，无法回答" in result['answer']:
+                result['answer']=retrieve_info
        return success(data=result, msg="回复对话消息成功")
    except BaseException as e:
        # Handle ExceptionGroup from TaskGroup (Python 3.11+) or BaseExceptionGroup
@@ -403,7 +404,7 @@ async def read_server_async(
    try:
        task = celery_app.send_task(
            "app.core.memory.agent.read_message",
-            args=[user_input.group_id, user_input.message, user_input.history, user_input.search_switch,
+            args=[user_input.end_user_id, user_input.message, user_input.history, user_input.search_switch,
                  config_id, storage_type, user_rag_memory_id]
        )
        api_logger.info(f"Read task queued: {task.id}")
@@ -447,7 +448,7 @@ async def get_read_task_result(
                return success(
                    data={
                        "result": task_result.get("result"),
-                        "group_id": task_result.get("group_id"),
+                        "end_user_id": task_result.get("end_user_id"),
                        "elapsed_time": task_result.get("elapsed_time"),
                        "task_id": task_id
                    },
@@ -524,7 +525,7 @@ async def get_write_task_result(
                return success(
                    data={
                        "result": task_result.get("result"),
-                        "group_id": task_result.get("group_id"),
+                        "end_user_id": task_result.get("end_user_id"),
                        "elapsed_time": task_result.get("elapsed_time"),
                        "task_id": task_id
                    },
@@ -578,16 +579,16 @@ async def status_type(
    Determine the type of user message (read or write)
    
    Args:
-        user_input: Request containing user message and group_id
+        user_input: Request containing user message and end_user_id
    
    Returns:
        Type classification result
    """
-    api_logger.info(f"Status type check requested for group {user_input.group_id}")
+    api_logger.info(f"Status type check requested for group {user_input.end_user_id}")
    try:
        # 获取标准化的消息列表
        messages_list = memory_agent_service.get_messages_list(user_input)
-        
+
        # 将消息列表转换为字符串用于分类
        # 只取最后一条用户消息进行分类
        last_user_message = ""
@@ -595,11 +596,11 @@ async def status_type(
            if msg.get('role') == 'user':
                last_user_message = msg.get('content', '')
                break
-        
+
        if not last_user_message:
            # 如果没有用户消息，使用所有消息的内容
            last_user_message = " ".join([msg.get('content', '') for msg in messages_list])
-        
+
        result = await memory_agent_service.classify_message_type(
            last_user_message,
            user_input.config_id,
@@ -624,7 +625,7 @@ async def get_knowledge_type_stats_api(
    会对缺失类型补 0，返回字典形式。
    可选按状态过滤。
    - 知识库类型根据当前用户的 current_workspace_id 过滤
-    - memory 是 Neo4j 中 Chunk 的数量，根据 end_user_id (group_id) 过滤
+    - memory 是 Neo4j 中 Chunk 的数量，根据 end_user_id (end_user_id) 过滤
    - 如果用户没有当前工作空间或未提供 end_user_id，对应的统计返回 0
    """
    api_logger.info(f"Knowledge type stats requested for workspace_id: {current_user.current_workspace_id}, end_user_id: {end_user_id}")
@@ -697,7 +698,7 @@ async def get_user_profile_api(
    current_user: User = Depends(get_current_user)
 ):
    """
-    获取工作空间下Popular Memory Tags，包含：
+    获取用户详情，包含：
    - name: 用户名字（直接使用 end_user_id）
    - tags: 3个用户特征标签（从语句和实体中LLM总结）
    - hot_tags: 4个热门记忆标签
--- a/api/app/controllers/memory_dashboard_controller.py
+++ b/api/app/controllers/memory_dashboard_controller.py
@@ -49,63 +49,134 @@ async def get_workspace_end_users(
    current_user: User = Depends(get_current_user),
 ):
    """
-    获取工作空间的宿主列表
+    获取工作空间的宿主列表（高性能优化版本 v2）
    
-    返回格式与原 memory_list 接口中的 end_users 字段相同，
-    并包含每个用户的记忆配置信息（memory_config_id 和 memory_config_name）
+    优化策略：
+    1. 批量查询 end_users（一次查询而非循环）
+    2. 并发查询所有用户的记忆数量（Neo4j）
+    3. RAG 模式使用批量查询（一次 SQL）
+    4. 只返回必要字段减少数据传输
+    5. 添加短期缓存减少重复查询
+    6. 并发执行配置查询和记忆数量查询
+    
+    返回格式：
+    {
+        "end_user": {"id": "uuid", "other_name": "名称"},
+        "memory_num": {"total": 数量},
+        "memory_config": {"memory_config_id": "id", "memory_config_name": "名称"}
+    }
    """
+    import asyncio
+    import json
+    from app.aioRedis import aio_redis_get, aio_redis_set
+    
    workspace_id = current_user.current_workspace_id
+    
+    # 尝试从缓存获取（30秒缓存）
+    cache_key = f"end_users:workspace:{workspace_id}"
+    try:
+        cached_data = await aio_redis_get(cache_key)
+        if cached_data:
+            api_logger.info(f"从缓存获取宿主列表: workspace_id={workspace_id}")
+            return success(data=json.loads(cached_data), msg="宿主列表获取成功")
+    except Exception as e:
+        api_logger.warning(f"Redis 缓存读取失败: {str(e)}")
+    
    # 获取当前空间类型
    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（已优化为批量查询）
    end_users = memory_dashboard_service.get_workspace_end_users(
        db=db,
        workspace_id=workspace_id,
        current_user=current_user
    )
-    
-    # 批量获取所有用户的记忆配置信息（优化：一次查询而非 N 次）
-    end_user_ids = [str(user.id) for user in end_users]
-    memory_configs_map = {}
-    if end_user_ids:
+    if not end_users:
+        api_logger.info("工作空间下没有宿主")
+        # 缓存空结果，避免重复查询
        try:
-            memory_configs_map = get_end_users_connected_configs_batch(end_user_ids, db)
+            await aio_redis_set(cache_key, json.dumps([]), expire=30)
+        except Exception as e:
+            api_logger.warning(f"Redis 缓存写入失败: {str(e)}")
+        return success(data=[], msg="宿主列表获取成功")
+    
+    end_user_ids = [str(user.id) for user in end_users]
+    
+    # 并发执行两个独立的查询任务
+    async def get_memory_configs():
+        """获取记忆配置（在线程池中执行同步查询）"""
+        try:
+            return await asyncio.to_thread(
+                get_end_users_connected_configs_batch,
+                end_user_ids, db
+            )
        except Exception as e:
            api_logger.error(f"批量获取记忆配置失败: {str(e)}")
-            # 失败时使用空字典，不影响其他数据返回
+            return {}
    
+    async def get_memory_nums():
+        """获取记忆数量"""
+        if current_workspace_type == "rag":
+            # RAG 模式：批量查询
+            try:
+                chunk_map = await asyncio.to_thread(
+                    memory_dashboard_service.get_users_total_chunk_batch,
+                    end_user_ids, db, current_user
+                )
+                return {uid: {"total": count} for uid, count in chunk_map.items()}
+            except Exception as e:
+                api_logger.error(f"批量获取 RAG chunk 数量失败: {str(e)}")
+                return {uid: {"total": 0} for uid in end_user_ids}
+        
+        elif current_workspace_type == "neo4j":
+            # Neo4j 模式：并发查询（带并发限制）
+            # 使用信号量限制并发数，避免大量用户时压垮 Neo4j
+            MAX_CONCURRENT_QUERIES = 10
+            semaphore = asyncio.Semaphore(MAX_CONCURRENT_QUERIES)
+            
+            async def get_neo4j_memory_num(end_user_id: str):
+                async with semaphore:
+                    try:
+                        return await memory_storage_service.search_all(end_user_id)
+                    except Exception as e:
+                        api_logger.error(f"获取用户 {end_user_id} Neo4j 记忆数量失败: {str(e)}")
+                        return {"total": 0}
+            
+            memory_nums_list = await asyncio.gather(*[get_neo4j_memory_num(uid) for uid in end_user_ids])
+            return {end_user_ids[i]: memory_nums_list[i] for i in range(len(end_user_ids))}
+        
+        return {uid: {"total": 0} for uid in end_user_ids}
+    
+    # 并发执行配置查询和记忆数量查询
+    memory_configs_map, memory_nums_map = await asyncio.gather(
+        get_memory_configs(),
+        get_memory_nums()
+    )
+    
+    # 构建结果（优化：使用列表推导式）
    result = []
    for end_user in end_users:
-        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)
-            }
-        
-        # 从批量查询结果中获取配置信息
        user_id = str(end_user.id)
-        memory_config_info = memory_configs_map.get(user_id, {
-            "memory_config_id": None,
-            "memory_config_name": None
-        })
-        
-        # 只保留需要的字段，移除 error 字段（如果有）
-        memory_config = {
-            "memory_config_id": memory_config_info.get("memory_config_id"),
-            "memory_config_name": memory_config_info.get("memory_config_name")
-        }
-        
-        result.append(
-            {
-                'end_user': end_user,
-                'memory_num': memory_num,
-                'memory_config': memory_config
+        config_info = memory_configs_map.get(user_id, {})
+        result.append({
+            'end_user': {
+                'id': user_id,
+                'other_name': end_user.other_name
+            },
+            'memory_num': memory_nums_map.get(user_id, {"total": 0}),
+            'memory_config': {
+                "memory_config_id": config_info.get("memory_config_id"),
+                "memory_config_name": config_info.get("memory_config_name")
            }
-        )
-        
+        })
+    
+    # 写入缓存（30秒过期）
+    try:
+        await aio_redis_set(cache_key, json.dumps(result), expire=30)
+    except Exception as e:
+        api_logger.warning(f"Redis 缓存写入失败: {str(e)}")
+    
    api_logger.info(f"成功获取 {len(end_users)} 个宿主记录")
    return success(data=result, msg="宿主列表获取成功")

--- a/api/app/controllers/memory_forget_controller.py
+++ b/api/app/controllers/memory_forget_controller.py
@@ -11,6 +11,7 @@
 """

 from typing import Optional
+from uuid import UUID

 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
@@ -33,7 +34,7 @@ from app.schemas.memory_storage_schema import (
 )
 from app.schemas.response_schema import ApiResponse
 from app.services.memory_forget_service import MemoryForgetService
-
+from app.utils.config_utils import resolve_config_id

 # 获取API专用日志器
 api_logger = get_api_logger()
@@ -83,7 +84,8 @@ async def trigger_forgetting_cycle(
        
        connected_config = get_end_user_connected_config(end_user_id, db)
        config_id = connected_config.get("memory_config_id")
-        
+        config_id = resolve_config_id((config_id), db)
+
        if config_id is None:
            api_logger.warning(f"终端用户 {end_user_id} 未关联记忆配置")
            return fail(BizCode.INVALID_PARAMETER, f"终端用户 {end_user_id} 未关联记忆配置", "memory_config_id is None")
@@ -106,7 +108,7 @@ async def trigger_forgetting_cycle(
        # 调用服务层执行遗忘周期
        report = await forget_service.trigger_forgetting_cycle(
            db=db,
-            group_id=end_user_id,  # 服务层方法的参数名是 group_id
+            end_user_id=end_user_id,  # 服务层方法的参数名是 end_user_id
            max_merge_batch_size=payload.max_merge_batch_size,
            min_days_since_access=payload.min_days_since_access,
            config_id=config_id
@@ -128,7 +130,7 @@ async def trigger_forgetting_cycle(

@router.get("/read_config", response_model=ApiResponse)
 async def read_forgetting_config(
-    config_id: int,
+    config_id: UUID|int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
 ):
@@ -157,6 +159,7 @@ async def read_forgetting_config(
    )
    
    try:
+        config_id=resolve_config_id(config_id, db)
        # 调用服务层读取配置
        config = forget_service.read_forgetting_config(db=db, config_id=config_id)
        
@@ -194,6 +197,8 @@ async def update_forgetting_config(
        ApiResponse: 包含更新结果的响应
    """
    workspace_id = current_user.current_workspace_id
+    payload.config_id=resolve_config_id((payload.config_id), db)
+
    
    # 检查用户是否已选择工作空间
    if workspace_id is None:
@@ -236,7 +241,7 @@ async def update_forgetting_config(

@router.get("/stats", response_model=ApiResponse)
 async def get_forgetting_stats(
-    group_id: Optional[str] = None,
+    end_user_id: Optional[str] = None,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
 ):
@@ -246,7 +251,7 @@ async def get_forgetting_stats(
    返回知识层节点统计、激活值分布等信息。
    
    Args:
-        group_id: 组ID（即 end_user_id，可选）
+        end_user_id: 组ID（即 end_user_id，可选）
        current_user: 当前用户
        db: 数据库会话
    
@@ -254,26 +259,25 @@ async def get_forgetting_stats(
        ApiResponse: 包含统计信息的响应
    """
    workspace_id = current_user.current_workspace_id
-    
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试获取遗忘引擎统计但未选择工作空间")
        return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")
-    
-    # 如果提供了 group_id，通过它获取 config_id
+    # 如果提供了 end_user_id，通过它获取 config_id
    config_id = None
-    if group_id:
+    if end_user_id:
        try:
            from app.services.memory_agent_service import get_end_user_connected_config
            
-            connected_config = get_end_user_connected_config(group_id, db)
+            connected_config = get_end_user_connected_config(end_user_id, db)
            config_id = connected_config.get("memory_config_id")
+            config_id = resolve_config_id(config_id, db)
            
            if config_id is None:
-                api_logger.warning(f"终端用户 {group_id} 未关联记忆配置")
-                return fail(BizCode.INVALID_PARAMETER, f"终端用户 {group_id} 未关联记忆配置", "memory_config_id is None")
+                api_logger.warning(f"终端用户 {end_user_id} 未关联记忆配置")
+                return fail(BizCode.INVALID_PARAMETER, f"终端用户 {end_user_id} 未关联记忆配置", "memory_config_id is None")
            
-            api_logger.debug(f"通过 group_id={group_id} 获取到 config_id={config_id}")
+            api_logger.debug(f"通过 end_user_id={end_user_id} 获取到 config_id={config_id}")
        except ValueError as e:
            api_logger.warning(f"获取终端用户配置失败: {str(e)}")
            return fail(BizCode.INVALID_PARAMETER, str(e), "ValueError")
@@ -283,14 +287,14 @@ async def get_forgetting_stats(
    
    api_logger.info(
        f"用户 {current_user.username} 在工作空间 {workspace_id} 请求获取遗忘引擎统计: "
-        f"group_id={group_id}, config_id={config_id}"
+        f"end_user_id={end_user_id}, config_id={config_id}"
    )
    
    try:
        # 调用服务层获取统计信息
        stats = await forget_service.get_forgetting_stats(
            db=db,
-            group_id=group_id,
+            end_user_id=end_user_id,
            config_id=config_id
        )
        
@@ -324,7 +328,7 @@ async def get_forgetting_curve(
        ApiResponse: 包含遗忘曲线数据的响应
    """
    workspace_id = current_user.current_workspace_id
-    
+    request.config_id = resolve_config_id((request.config_id), db)
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试获取遗忘曲线但未选择工作空间")
--- a/api/app/controllers/memory_perceptual_controller.py
+++ b/api/app/controllers/memory_perceptual_controller.py
@@ -27,27 +27,27 @@ router = APIRouter(
 )


-@router.get("/{group_id}/count", response_model=ApiResponse)
+@router.get("/{end_user_id}/count", response_model=ApiResponse)
 def get_memory_count(
-        group_id: uuid.UUID,
+        end_user_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db)
 ):
    """Retrieve perceptual memory statistics for a user group.

    Args:
-        group_id: ID of the user group (usually end_user_id in this context)
+        end_user_id: ID of the user group (usually end_user_id in this context)
        current_user: Current authenticated user
        db: Database session

    Returns:
        ApiResponse: Response containing memory count statistics
    """
-    api_logger.info(f"Fetching perceptual memory statistics: user={current_user.username}, group_id={group_id}")
+    api_logger.info(f"Fetching perceptual memory statistics: user={current_user.username}, end_user_id={end_user_id}")

    try:
        service = MemoryPerceptualService(db)
-        count_stats = service.get_memory_count(group_id)
+        count_stats = service.get_memory_count(end_user_id)

        api_logger.info(f"Memory statistics fetched successfully: total={count_stats.get('total', 0)}")

@@ -57,37 +57,37 @@ def get_memory_count(
        )

    except Exception as e:
-        api_logger.error(f"Failed to fetch memory statistics: group_id={group_id}, error={str(e)}")
+        api_logger.error(f"Failed to fetch memory statistics: end_user_id={end_user_id}, error={str(e)}")
        return fail(
            code=BizCode.INTERNAL_ERROR,
            msg="Failed to fetch memory statistics",
        )


-@router.get("/{group_id}/last_visual", response_model=ApiResponse)
+@router.get("/{end_user_id}/last_visual", response_model=ApiResponse)
 def get_last_visual_memory(
-        group_id: uuid.UUID,
+        end_user_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db)
 ):
    """Retrieve the most recent VISION-type memory for a user.

    Args:
-        group_id: ID of the user group
+        end_user_id: ID of the user group
        current_user: Current authenticated user
        db: Database session

    Returns:
        ApiResponse: Metadata of the latest visual memory
    """
-    api_logger.info(f"Fetching latest visual memory: user={current_user.username}, group_id={group_id}")
+    api_logger.info(f"Fetching latest visual memory: user={current_user.username}, end_user_id={end_user_id}")

    try:
        service = MemoryPerceptualService(db)
-        visual_memory = service.get_latest_visual_memory(group_id)
+        visual_memory = service.get_latest_visual_memory(end_user_id)

        if visual_memory is None:
-            api_logger.info(f"No visual memory found: group_id={group_id}")
+            api_logger.info(f"No visual memory found: end_user_id={end_user_id}")
            return success(
                data=None,
                msg="No visual memory available"
@@ -101,37 +101,37 @@ def get_last_visual_memory(
        )

    except Exception as e:
-        api_logger.error(f"Failed to fetch latest visual memory: group_id={group_id}, error={str(e)}")
+        api_logger.error(f"Failed to fetch latest visual memory: end_user_id={end_user_id}, error={str(e)}")
        return fail(
            code=BizCode.INTERNAL_ERROR,
            msg="Failed to fetch latest visual memory",
        )


-@router.get("/{group_id}/last_listen", response_model=ApiResponse)
+@router.get("/{end_user_id}/last_listen", response_model=ApiResponse)
 def get_last_memory_listen(
-        group_id: uuid.UUID,
+        end_user_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db)
 ):
    """Retrieve the most recent AUDIO-type memory for a user.

    Args:
-        group_id: ID of the user group
+        end_user_id: ID of the user group
        current_user: Current authenticated user
        db: Database session

    Returns:
        ApiResponse: Metadata of the latest audio memory
    """
-    api_logger.info(f"Fetching latest audio memory: user={current_user.username}, group_id={group_id}")
+    api_logger.info(f"Fetching latest audio memory: user={current_user.username}, end_user_id={end_user_id}")

    try:
        service = MemoryPerceptualService(db)
-        audio_memory = service.get_latest_audio_memory(group_id)
+        audio_memory = service.get_latest_audio_memory(end_user_id)

        if audio_memory is None:
-            api_logger.info(f"No audio memory found: group_id={group_id}")
+            api_logger.info(f"No audio memory found: end_user_id={end_user_id}")
            return success(
                data=None,
                msg="No audio memory available"
@@ -145,38 +145,38 @@ def get_last_memory_listen(
        )

    except Exception as e:
-        api_logger.error(f"Failed to fetch latest audio memory: group_id={group_id}, error={str(e)}")
+        api_logger.error(f"Failed to fetch latest audio memory: end_user_id={end_user_id}, error={str(e)}")
        return fail(
            code=BizCode.INTERNAL_ERROR,
            msg="Failed to fetch latest audio memory",
        )


-@router.get("/{group_id}/last_text", response_model=ApiResponse)
+@router.get("/{end_user_id}/last_text", response_model=ApiResponse)
 def get_last_text_memory(
-        group_id: uuid.UUID,
+        end_user_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db)
 ):
    """Retrieve the most recent TEXT-type memory for a user.

    Args:
-        group_id: ID of the user group
+        end_user_id: ID of the user group
        current_user: Current authenticated user
        db: Database session

    Returns:
        ApiResponse: Metadata of the latest text memory
    """
-    api_logger.info(f"Fetching latest text memory: user={current_user.username}, group_id={group_id}")
+    api_logger.info(f"Fetching latest text memory: user={current_user.username}, end_user_id={end_user_id}")

    try:
        # 调用服务层获取最近的文本记忆
        service = MemoryPerceptualService(db)
-        text_memory = service.get_latest_text_memory(group_id)
+        text_memory = service.get_latest_text_memory(end_user_id)

        if text_memory is None:
-            api_logger.info(f"No text memory found: group_id={group_id}")
+            api_logger.info(f"No text memory found: end_user_id={end_user_id}")
            return success(
                data=None,
                msg="No text memory available"
@@ -190,16 +190,16 @@ def get_last_text_memory(
        )

    except Exception as e:
-        api_logger.error(f"Failed to fetch latest text memory: group_id={group_id}, error={str(e)}")
+        api_logger.error(f"Failed to fetch latest text memory: end_user_id={end_user_id}, error={str(e)}")
        return fail(
            code=BizCode.INTERNAL_ERROR,
            msg="Failed to fetch latest text memory",
        )


-@router.get("/{group_id}/timeline", response_model=ApiResponse)
+@router.get("/{end_user_id}/timeline", response_model=ApiResponse)
 def get_memory_time_line(
-        group_id: uuid.UUID,
+        end_user_id: uuid.UUID,
        perceptual_type: Optional[PerceptualType] = Query(None, description="感知类型过滤"),
        page: int = Query(1, ge=1, description="页码"),
        page_size: int = Query(10, ge=1, le=100, description="每页大小"),
@@ -209,7 +209,7 @@ def get_memory_time_line(
    """Retrieve a timeline of perceptual memories for a user group.

    Args:
-        group_id: ID of the user group
+        end_user_id: ID of the user group
        perceptual_type: Optional filter for perceptual type
        page: Page number for pagination
        page_size: Number of items per page
@@ -221,7 +221,7 @@ def get_memory_time_line(
    """
    api_logger.info(
        f"Fetching perceptual memory timeline: user={current_user.username}, "
-        f"group_id={group_id}, type={perceptual_type}, page={page}"
+        f"end_user_id={end_user_id}, type={perceptual_type}, page={page}"
    )

    try:
@@ -232,7 +232,7 @@ def get_memory_time_line(
        )

        service = MemoryPerceptualService(db)
-        timeline_data = service.get_time_line(group_id, query)
+        timeline_data = service.get_time_line(end_user_id, query)

        api_logger.info(
            f"Perceptual memory timeline retrieved successfully: total={timeline_data.total}, "
@@ -246,7 +246,7 @@ def get_memory_time_line(

    except Exception as e:
        api_logger.error(
-            f"Failed to fetch perceptual memory timeline: group_id={group_id}, "
+            f"Failed to fetch perceptual memory timeline: end_user_id={end_user_id}, "
            f"error={str(e)}"
        )
        return fail(
--- a/api/app/controllers/memory_reflection_controller.py
+++ b/api/app/controllers/memory_reflection_controller.py
@@ -1,6 +1,7 @@
 import asyncio
 import time
 import uuid
+from uuid import UUID

 from app.core.logging_config import get_api_logger
 from app.core.memory.storage_services.reflection_engine.self_reflexion import (
@@ -11,7 +12,7 @@ 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.repositories.data_config_repository import DataConfigRepository
+from app.repositories.memory_config_repository import MemoryConfigRepository
 from app.repositories.neo4j.neo4j_connector import Neo4jConnector
 from app.schemas.memory_reflection_schemas import Memory_Reflection
 from app.services.memory_reflection_service import (
@@ -24,6 +25,8 @@ from fastapi import APIRouter, Depends, HTTPException, status,Header
 from sqlalchemy import text
 from sqlalchemy.orm import Session

+from app.utils.config_utils import resolve_config_id
+
 load_dotenv()
 api_logger = get_api_logger()

@@ -42,6 +45,7 @@ async def save_reflection_config(
    """Save reflection configuration to data_comfig table"""
    try:
        config_id = request.config_id
+        config_id = resolve_config_id(config_id, db)
        if not config_id:
            raise HTTPException(
                status_code=status.HTTP_400_BAD_REQUEST,
@@ -50,7 +54,7 @@ async def save_reflection_config(

        api_logger.info(f"用户 {current_user.username} 保存反思配置，config_id: {config_id}")

-        data_config = DataConfigRepository.update_reflection_config(
+        memory_config = MemoryConfigRepository.update_reflection_config(
            db,
            config_id=config_id,
            enable_self_reflexion=request.reflection_enabled,
@@ -63,17 +67,17 @@ async def save_reflection_config(
        )

        db.commit()
-        db.refresh(data_config)
+        db.refresh(memory_config)

        reflection_result={
-                "config_id": data_config.config_id,
-                "enable_self_reflexion": data_config.enable_self_reflexion,
-                "iteration_period": data_config.iteration_period,
-                "reflexion_range": data_config.reflexion_range,
-                "baseline": data_config.baseline,
-                "reflection_model_id": data_config.reflection_model_id,
-                "memory_verify": data_config.memory_verify,
-                "quality_assessment": data_config.quality_assessment}
+                "config_id": memory_config.config_id,
+                "enable_self_reflexion": memory_config.enable_self_reflexion,
+                "iteration_period": memory_config.iteration_period,
+                "reflexion_range": memory_config.reflexion_range,
+                "baseline": memory_config.baseline,
+                "reflection_model_id": memory_config.reflection_model_id,
+                "memory_verify": memory_config.memory_verify,
+                "quality_assessment": memory_config.quality_assessment}

        return success(data=reflection_result, msg="反思配置成功")
        
@@ -111,14 +115,14 @@ async def start_workspace_reflection(
        reflection_results = []
        
        for data in result['apps_detailed_info']:
-            if data['data_configs'] == []: 
+            if data['memory_configs'] == []: 
                continue
                
            releases = data['releases']
-            data_configs = data['data_configs']
+            memory_configs = data['memory_configs']
            end_users = data['end_users']
            
-            for base, config, user in zip(releases, data_configs, end_users):
+            for base, config, user in zip(releases, memory_configs, end_users):
                # 安全地转换为整数，处理空字符串和None的情况
                print(base['config'])
                try:
@@ -156,17 +160,20 @@ async def start_workspace_reflection(

@router.get("/reflection/configs")
 async def start_reflection_configs(
-        config_id: int,
+        config_id: uuid.UUID|int,
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db),
 ) -> dict:
-    """通过config_id查询data_config表中的反思配置信息"""
+    """通过config_id查询memory_config表中的反思配置信息"""
+    config_id = resolve_config_id(config_id, db)
    try:
+        config_id=resolve_config_id(config_id,db)
        api_logger.info(f"用户 {current_user.username} 查询反思配置，config_id: {config_id}")
-        result = DataConfigRepository.query_reflection_config_by_id(db, config_id)
+        result = MemoryConfigRepository.query_reflection_config_by_id(db, config_id)
+        memory_config_id = resolve_config_id(result.config_id, db)
        # 构建返回数据
        reflection_config = {
-            "config_id": result.config_id,
+            "config_id": memory_config_id,
            "reflection_enabled": result.enable_self_reflexion,
            "reflection_period_in_hours": result.iteration_period,
            "reflexion_range": result.reflexion_range,
@@ -191,7 +198,7 @@ async def start_reflection_configs(

@router.get("/reflection/run")
 async def reflection_run(
-    config_id: int,
+    config_id: UUID|int,
    language_type: str = Header(default="zh", alias="X-Language-Type"),
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
@@ -199,9 +206,9 @@ async def reflection_run(
    """Activate the reflection function for all matching applications in the workspace"""

    api_logger.info(f"用户 {current_user.username} 查询反思配置，config_id: {config_id}")
-
-    # 使用DataConfigRepository查询反思配置
-    result = DataConfigRepository.query_reflection_config_by_id(db, config_id)
+    config_id = resolve_config_id(config_id, db)
+    # 使用MemoryConfigRepository查询反思配置
+    result = MemoryConfigRepository.query_reflection_config_by_id(db, config_id)
    if not result:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
--- a/api/app/controllers/memory_storage_controller.py
+++ b/api/app/controllers/memory_storage_controller.py
@@ -1,5 +1,6 @@
 import os
 from typing import Optional
+from uuid import UUID

 from app.core.error_codes import BizCode
 from app.core.logging_config import get_api_logger
@@ -34,6 +35,8 @@ from fastapi import APIRouter, Depends
 from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session

+from app.utils.config_utils import resolve_config_id
+
 # Get API logger
 api_logger = get_api_logger()

@@ -140,7 +143,6 @@ def create_config(
    db: Session = Depends(get_db),
    ) -> dict:
    workspace_id = current_user.current_workspace_id
-    
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试创建配置但未选择工作空间")
@@ -160,12 +162,12 @@ def create_config(

@router.delete("/delete_config", response_model=ApiResponse)  # 删除数据库中的内容（按配置名称）
 def delete_config(
-    config_id: str,
+    config_id: UUID|int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
    ) -> dict:
    workspace_id = current_user.current_workspace_id
-    
+    config_id=resolve_config_id(config_id, db)
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试删除配置但未选择工作空间")
@@ -187,7 +189,7 @@ def update_config(
    db: Session = Depends(get_db),
    ) -> dict:
    workspace_id = current_user.current_workspace_id
-    
+    payload.config_id = resolve_config_id(payload.config_id, db)
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试更新配置但未选择工作空间")
@@ -210,7 +212,7 @@ def update_config_extracted(
    db: Session = Depends(get_db),
    ) -> dict:
    workspace_id = current_user.current_workspace_id
-    
+    payload.config_id = resolve_config_id(payload.config_id, db)
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试更新提取配置但未选择工作空间")
@@ -232,12 +234,12 @@ def update_config_extracted(

@router.get("/read_config_extracted", response_model=ApiResponse) # 通过查询参数读取某条配置（固定路径） 没有意义的话就删除
 def read_config_extracted(
-    config_id: str,
+    config_id: UUID | int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db),
    ) -> dict:
    workspace_id = current_user.current_workspace_id
-    
+    config_id = resolve_config_id(config_id, db)
    # 检查用户是否已选择工作空间
    if workspace_id is None:
        api_logger.warning(f"用户 {current_user.username} 尝试读取提取配置但未选择工作空间")
@@ -285,6 +287,7 @@ async def pilot_run(
        f"Pilot run requested: config_id={payload.config_id}, "
        f"dialogue_text_length={len(payload.dialogue_text)}"
    )
+    payload.config_id = resolve_config_id(payload.config_id, db)
    svc = DataConfigService(db)
    return StreamingResponse(
        svc.pilot_run_stream(payload),
@@ -420,15 +423,95 @@ async def get_hot_memory_tags_api(
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user),
    ) -> dict:
-    api_logger.info(f"Hot memory tags requested for current_user: {current_user.id}")
+    """
+    获取热门记忆标签（带Redis缓存）
+    
+    缓存策略：
+    - 缓存键：workspace_id + limit
+    - 过期时间：5分钟（300秒）
+    - 缓存命中：~50ms
+    - 缓存未命中：~600-800ms（取决于LLM速度）
+    """
+    workspace_id = current_user.current_workspace_id
+    
+    # 构建缓存键
+    cache_key = f"hot_memory_tags:{workspace_id}:{limit}"
+    
+    api_logger.info(f"Hot memory tags requested for workspace: {workspace_id}, limit: {limit}")
+    
    try:
+        # 尝试从Redis缓存获取
+        from app.aioRedis import aio_redis_get, aio_redis_set
+        import json
+        
+        cached_result = await aio_redis_get(cache_key)
+        if cached_result:
+            api_logger.info(f"Cache hit for key: {cache_key}")
+            try:
+                data = json.loads(cached_result)
+                return success(data=data, msg="查询成功（缓存）")
+            except json.JSONDecodeError:
+                api_logger.warning(f"Failed to parse cached data, will refresh")
+        
+        # 缓存未命中，执行查询
+        api_logger.info(f"Cache miss for key: {cache_key}, executing query")
        result = await analytics_hot_memory_tags(db, current_user, limit)
+        
+        # 写入缓存（过期时间：5分钟）
+        # 注意：result是列表，需要转换为JSON字符串
+        try:
+            cache_data = json.dumps(result, ensure_ascii=False)
+            await aio_redis_set(cache_key, cache_data, expire=300)
+            api_logger.info(f"Cached result for key: {cache_key}")
+        except Exception as cache_error:
+            # 缓存写入失败不影响主流程
+            api_logger.warning(f"Failed to cache result: {str(cache_error)}")
+        
        return success(data=result, msg="查询成功")
+        
    except Exception as e:
        api_logger.error(f"Hot memory tags failed: {str(e)}")
        return fail(BizCode.INTERNAL_ERROR, "热门标签查询失败", str(e))


+@router.delete("/analytics/hot_memory_tags/cache", response_model=ApiResponse)
+async def clear_hot_memory_tags_cache(
+    current_user: User = Depends(get_current_user),
+    ) -> dict:
+    """
+    清除热门标签缓存
+    
+    用于：
+    - 手动刷新数据
+    - 调试和测试
+    - 数据更新后立即生效
+    """
+    workspace_id = current_user.current_workspace_id
+    
+    api_logger.info(f"Clear hot memory tags cache requested for workspace: {workspace_id}")
+    
+    try:
+        from app.aioRedis import aio_redis_delete
+        
+        # 清除所有limit的缓存（常见的limit值）
+        cleared_count = 0
+        for limit in [5, 10, 15, 20, 30, 50]:
+            cache_key = f"hot_memory_tags:{workspace_id}:{limit}"
+            result = await aio_redis_delete(cache_key)
+            if result:
+                cleared_count += 1
+                api_logger.info(f"Cleared cache for key: {cache_key}")
+        
+        return success(
+            data={"cleared_count": cleared_count}, 
+            msg=f"成功清除 {cleared_count} 个缓存"
+        )
+        
+    except Exception as e:
+        api_logger.error(f"Clear cache failed: {str(e)}")
+        return fail(BizCode.INTERNAL_ERROR, "清除缓存失败", str(e))
+
+
@router.get("/analytics/recent_activity_stats", response_model=ApiResponse)
 async def get_recent_activity_stats_api(
    current_user: User = Depends(get_current_user),
--- a/api/app/controllers/memory_working_controller.py
+++ b/api/app/controllers/memory_working_controller.py
@@ -20,18 +20,18 @@ router = APIRouter(
 )


-@router.get("/{group_id}/count", response_model=ApiResponse)
+@router.get("/{end_user_id}/count", response_model=ApiResponse)
 def get_memory_count(
-        group_id: uuid.UUID,
+        end_user_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db)
 ):
    pass


-@router.get("/{group_id}/conversations", response_model=ApiResponse)
+@router.get("/{end_user_id}/conversations", response_model=ApiResponse)
 def get_conversations(
-        group_id: uuid.UUID,
+        end_user_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
        db: Session = Depends(get_db)
 ):
@@ -39,7 +39,7 @@ def get_conversations(
    Retrieve all conversations for the current user in a specific group.

    Args:
-        group_id (UUID): The group identifier.
+        end_user_id (UUID): The group identifier.
        current_user (User, optional): The authenticated user.
        db (Session, optional): SQLAlchemy session.

@@ -53,7 +53,7 @@ def get_conversations(
    """
    conversation_service = ConversationService(db)
    conversations = conversation_service.get_user_conversations(
-        group_id
+        end_user_id
    )
    return success(data=[
        {
@@ -63,7 +63,7 @@ def get_conversations(
    ], msg="get conversations success")


-@router.get("/{group_id}/messages", response_model=ApiResponse)
+@router.get("/{end_user_id}/messages", response_model=ApiResponse)
 def get_messages(
        conversation_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
@@ -100,7 +100,7 @@ def get_messages(
    return success(data=messages, msg="get conversation history success")


-@router.get("/{group_id}/detail", response_model=ApiResponse)
+@router.get("/{end_user_id}/detail", response_model=ApiResponse)
 async def get_conversation_detail(
        conversation_id: uuid.UUID,
        current_user: User = Depends(get_current_user),
--- a/api/app/controllers/model_controller.py
+++ b/api/app/controllers/model_controller.py
@@ -3,15 +3,17 @@ from sqlalchemy.orm import Session
 from typing import Optional
 import uuid

-
+from app.core.error_codes import BizCode
+from app.core.exceptions import BusinessException
 from app.db import get_db
 from app.dependencies import get_current_user
-from app.models.models_model import ModelProvider, ModelType
+from app.models.models_model import ModelProvider, ModelType, LoadBalanceStrategy
 from app.models.user_model import User
+from app.repositories.model_repository import ModelConfigRepository
 from app.schemas import model_schema
 from app.core.response_utils import success
 from app.schemas.response_schema import ApiResponse, PageData
-from app.services.model_service import ModelConfigService, ModelApiKeyService
+from app.services.model_service import ModelConfigService, ModelApiKeyService, ModelBaseService
 from app.core.logging_config import get_api_logger

 # 获取API专用日志器
@@ -24,24 +26,83 @@ router = APIRouter(

@router.get("/type", response_model=ApiResponse)
 def get_model_types():
-    
    return success(msg="获取模型类型成功", data=list(ModelType))


@router.get("/provider", response_model=ApiResponse)
 def get_model_providers():
-    return success(msg="获取模型提供商成功", data=list(ModelProvider))
+    providers = [p for p in ModelProvider if p != ModelProvider.COMPOSITE]
+    return success(msg="获取模型提供商成功", data=providers)
+
+@router.get("/strategy", response_model=ApiResponse)
+def get_model_strategies():
+    return success(msg="获取模型策略成功", data=list(LoadBalanceStrategy))


@router.get("", response_model=ApiResponse)
 def get_model_list(
-    type: Optional[str] = Query(None, description="模型类型筛选（支持多个，如 ?type=LLM 或 ?type=LLM,EMBEDDING）"),
-    provider: Optional[model_schema.ModelProvider] = Query(None, description="提供商筛选(基于API Key)"),
+        type: Optional[list[str]] = Query(None, description="模型类型筛选（支持多个，如 ?type=LLM 或 ?type=LLM,EMBEDDING）"),
+        provider: Optional[model_schema.ModelProvider] = Query(None, description="提供商筛选(基于API Key)"),
+        is_active: Optional[bool] = Query(None, description="激活状态筛选"),
+        is_public: Optional[bool] = Query(None, description="公开状态筛选"),
+        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),
+        current_user: User = Depends(get_current_user)
+):
+    """
+    获取模型配置列表
+
+    支持多个 type 参数：
+    - 单个：?type=LLM
+    - 多个（逗号分隔）：?type=LLM,EMBEDDING
+    - 多个（重复参数）：?type=LLM&type=EMBEDDING
+    """
+    api_logger.info(
+        f"获取模型配置列表请求: type={type}, provider={provider}, page={page}, pagesize={pagesize}, tenant_id={current_user.tenant_id}")
+
+    try:
+        # 解析 type 参数（支持逗号分隔）
+        type_list = []
+        if type is not None:
+            flat_type = []
+            for item in type:
+                split_items = [t.strip() for t in item.split(',') if t.strip()]
+                flat_type.extend(split_items)
+
+            unique_flat_type = list(dict.fromkeys(flat_type))
+            type_list = [ModelType(t.lower()) for t in unique_flat_type]
+
+        api_logger.error(f"获取模型type_list: {type_list}")
+        query = model_schema.ModelConfigQuery(
+            type=type_list,
+            provider=provider,
+            is_active=is_active,
+            is_public=is_public,
+            search=search,
+            page=page,
+            pagesize=pagesize
+        )
+
+        api_logger.debug(f"开始获取模型配置列表: {query.dict()}")
+        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="模型配置列表获取成功")
+    except Exception as e:
+        api_logger.error(f"获取模型配置列表失败: {str(e)}")
+        raise
+
+
+@router.get("/new", response_model=ApiResponse)
+def get_model_list_new(
+    type: Optional[list[str]] = Query(None, description="模型类型筛选（支持多个，如 ?type=LLM 或 ?type=LLM,EMBEDDING）"),
+    provider: Optional[model_schema.ModelProvider] = Query(None, description="提供商筛选(基于ModelConfig)"),
    is_active: Optional[bool] = Query(None, description="激活状态筛选"),
    is_public: Optional[bool] = Query(None, description="公开状态筛选"),
    search: Optional[str] = Query(None, description="搜索关键词"),
-    page: int = Query(1, ge=1, description="页码"),
-    pagesize: int = Query(10, ge=1, le=100, description="每页数量"),
+    is_composite: Optional[bool] = Query(None, description="组合模型筛选"),
    db: Session = Depends(get_db),
    current_user: User = Depends(get_current_user)
 ):
@@ -53,36 +114,127 @@ def get_model_list(
    - 多个（逗号分隔）：?type=LLM,EMBEDDING
    - 多个（重复参数）：?type=LLM&type=EMBEDDING
    """
-    api_logger.info(f"获取模型配置列表请求: type={type}, provider={provider}, page={page}, pagesize={pagesize}, tenant_id={current_user.tenant_id}")
+    api_logger.info(f"获取模型配置列表请求: type={type}, provider={provider}, tenant_id={current_user.tenant_id}")
    
    try:
        # 解析 type 参数（支持逗号分隔）
-        type_list = None
-        if type:
-            type_values = [t.strip() for t in type.split(',')]
-            type_list = [model_schema.ModelType(t.lower()) for t in type_values if t]
+        type_list = []
+        if type is not None:
+            flat_type = []
+            for item in type:
+                split_items = [t.strip() for t in item.split(',') if t.strip()]
+                flat_type.extend(split_items)
+
+            unique_flat_type = list(dict.fromkeys(flat_type))
+            type_list = [ModelType(t.lower()) for t in unique_flat_type]
        
-        api_logger.error(f"获取模型type_list: {type_list}")
-        query = model_schema.ModelConfigQuery(
+        api_logger.info(f"获取模型type_list: {type_list}")
+        query = model_schema.ModelConfigQueryNew(
            type=type_list,
            provider=provider,
            is_active=is_active,
            is_public=is_public,
-            search=search,
-            page=page,
-            pagesize=pagesize
+            is_composite=is_composite,
+            search=search
        )
        
-        api_logger.debug(f"开始获取模型配置列表: {query.dict()}")
-        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)}")
+        api_logger.debug(f"开始获取模型配置列表: {query.model_dump()}")
+        result = ModelConfigService.get_model_list_new(db=db, query=query, tenant_id=current_user.tenant_id)
+        api_logger.info(f"模型配置列表获取成功: 分组数={len(result)}, 总模型数={sum(len(item['models']) for item in result)}")
        return success(data=result, msg="模型配置列表获取成功")
    except Exception as e:
        api_logger.error(f"获取模型配置列表失败: {str(e)}")
        raise


+@router.get("/model_plaza", response_model=ApiResponse)
+def get_model_plaza_list(
+    type: Optional[ModelType] = Query(None, description="模型类型"),
+    provider: Optional[ModelProvider] = Query(None, description="供应商"),
+    is_official: Optional[bool] = Query(None, description="是否官方模型"),
+    is_deprecated: Optional[bool] = Query(None, description="是否弃用"),
+    search: Optional[str] = Query(None, description="搜索关键词"),
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """模型广场查询接口（按供应商分组）"""
+    
+    query = model_schema.ModelBaseQuery(
+        type=type,
+        provider=provider,
+        is_official=is_official,
+        is_deprecated=is_deprecated,
+        search=search
+    )
+    result = ModelBaseService.get_model_base_list(db=db, query=query, tenant_id=current_user.tenant_id)
+    return success(data=result, msg="模型广场列表获取成功")
+
+
+@router.get("/model_plaza/{model_base_id}", response_model=ApiResponse)
+def get_model_base_by_id(
+    model_base_id: uuid.UUID,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """获取基础模型详情"""
+    
+    result = ModelBaseService.get_model_base_by_id(db=db, model_base_id=model_base_id)
+    return success(data=model_schema.ModelBase.model_validate(result), msg="基础模型获取成功")
+
+
+@router.post("/model_plaza", response_model=ApiResponse)
+def create_model_base(
+    data: model_schema.ModelBaseCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """创建基础模型"""
+    
+    result = ModelBaseService.create_model_base(db=db, data=data)
+    return success(data=model_schema.ModelBase.model_validate(result), msg="基础模型创建成功")
+
+
+@router.put("/model_plaza/{model_base_id}", response_model=ApiResponse)
+def update_model_base(
+    model_base_id: uuid.UUID,
+    data: model_schema.ModelBaseUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """更新基础模型"""
+    
+    # 不允许更改type类型
+    if data.type is not None or data.provider is not None:
+        raise BusinessException("不允许更改模型类型和供应商", BizCode.INVALID_PARAMETER)
+    
+    result = ModelBaseService.update_model_base(db=db, model_base_id=model_base_id, data=data)
+    return success(data=model_schema.ModelBase.model_validate(result), msg="基础模型更新成功")
+
+
+@router.delete("/model_plaza/{model_base_id}", response_model=ApiResponse)
+def delete_model_base(
+    model_base_id: uuid.UUID,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """删除基础模型"""
+    
+    ModelBaseService.delete_model_base(db=db, model_base_id=model_base_id)
+    return success(msg="基础模型删除成功")
+
+
+@router.post("/model_plaza/{model_base_id}/add", response_model=ApiResponse)
+def add_model_from_plaza(
+    model_base_id: uuid.UUID,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """从模型广场添加模型到模型列表"""
+    
+    result = ModelBaseService.add_model_from_plaza(db=db, model_base_id=model_base_id, tenant_id=current_user.tenant_id)
+    return success(data=model_schema.ModelConfig.model_validate(result), msg="模型添加成功")
+
+
@router.get("/{model_id}", response_model=ApiResponse)
 def get_model_by_id(
    model_id: uuid.UUID,
@@ -138,6 +290,73 @@ async def create_model(
        raise


+@router.post("/composite", response_model=ApiResponse)
+async def create_composite_model(
+    model_data: model_schema.CompositeModelCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """
+    创建组合模型
+    
+    - 绑定一个或多个现有的 API Key
+    - 所有 API Key 必须来自非组合模型
+    - 所有 API Key 关联的模型类型必须与组合模型类型一致
+    """
+    api_logger.info(f"创建组合模型请求: {model_data.name}, 用户: {current_user.username}, tenant_id={current_user.tenant_id}")
+    
+    try:
+        result_orm = await ModelConfigService.create_composite_model(db=db, model_data=model_data, tenant_id=current_user.tenant_id)
+        api_logger.info(f"组合模型创建成功: {result_orm.name} (ID: {result_orm.id})")
+        
+        result = model_schema.ModelConfig.model_validate(result_orm)
+        return success(data=result, msg="组合模型创建成功")
+    except Exception as e:
+        api_logger.error(f"创建组合模型失败: {model_data.name} - {str(e)}")
+        raise
+
+
+@router.put("/composite/{model_id}", response_model=ApiResponse)
+async def update_composite_model(
+    model_id: uuid.UUID,
+    model_data: model_schema.CompositeModelCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """更新组合模型"""
+    api_logger.info(f"更新组合模型请求: model_id={model_id}, 用户: {current_user.username}")
+    
+    try:
+        if model_data.type is not None:
+            raise BusinessException("不允许更改模型类型和供应商", BizCode.INVALID_PARAMETER)
+        result_orm = await ModelConfigService.update_composite_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})")
+        
+        result = model_schema.ModelConfig.model_validate(result_orm)
+        return success(data=result, msg="组合模型更新成功")
+    except Exception as e:
+        api_logger.error(f"更新组合模型失败: model_id={model_id} - {str(e)}")
+        raise
+
+
+@router.delete("/composite/{model_id}", response_model=ApiResponse)
+def delete_composite_model(
+    model_id: uuid.UUID,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_current_user)
+):
+    """删除组合模型"""
+    api_logger.info(f"删除组合模型请求: model_id={model_id}, 用户: {current_user.username}")
+    
+    try:
+        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:
+        api_logger.error(f"删除组合模型失败: model_id={model_id} - {str(e)}")
+        raise
+
+
@router.put("/{model_id}", response_model=ApiResponse)
 def update_model(
    model_id: uuid.UUID,
@@ -214,6 +433,53 @@ def get_model_api_keys(
        raise


+@router.post("/provider/apikeys", response_model=ApiResponse)
+async def create_model_api_key_by_provider(
+        api_key_data: model_schema.ModelApiKeyCreateByProvider,
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_user)
+):
+    """
+    根据供应商为所有匹配的模型创建API Key
+    """
+    api_logger.info(f"创建API Key请求: provider={api_key_data.provider}, 用户: {current_user.username}")
+
+    try:
+        # 根据tenant_id和provider筛选model_config_id列表
+        model_config_ids = api_key_data.model_config_ids
+        if not model_config_ids:
+            model_config_ids = ModelConfigRepository.get_model_config_ids_by_provider(
+                db=db,
+                tenant_id=current_user.tenant_id,
+                provider=api_key_data.provider
+            )
+        
+        if not model_config_ids:
+            raise BusinessException(f"未找到供应商 {api_key_data.provider} 的模型配置", BizCode.MODEL_NOT_FOUND)
+        
+        # 构造schema并调用service
+        create_data = model_schema.ModelApiKeyCreateByProvider(
+            provider=api_key_data.provider,
+            api_key=api_key_data.api_key,
+            api_base=api_key_data.api_base,
+            description=api_key_data.description,
+            config=api_key_data.config,
+            is_active=api_key_data.is_active,
+            priority=api_key_data.priority,
+            model_config_ids=model_config_ids
+        )
+        created_keys, failed_models = await ModelApiKeyService.create_api_key_by_provider(db=db, data=create_data)
+        
+        api_logger.info(f"API Key创建成功: 关联{len(created_keys)}个模型")
+        # result_list = [model_schema.ModelApiKey.model_validate(key) for key in created_keys]
+        result = "API Key已存在" if len(created_keys) == 0 and len(failed_models) == 0 else \
+            f"成功为 {len(created_keys)} 个模型创建API Key, 失败模型列表{failed_models}"
+        return success(data=result, msg=f"成功为 {len(created_keys)} 个模型创建API Key")
+    except Exception as e:
+        api_logger.error(f"创建API Key失败: {str(e)}")
+        raise
+
+
@router.post("/{model_id}/apikeys", response_model=ApiResponse, status_code=status.HTTP_201_CREATED)
 async def create_model_api_key(
    model_id: uuid.UUID,
@@ -228,11 +494,12 @@ async def create_model_api_key(
    
    try:
        # 设置模型配置ID
-        api_key_data.model_config_id = model_id
+        api_key_data.model_config_ids = [model_id]
        
        api_logger.debug(f"开始创建模型API Key: {api_key_data.model_name}")
-        result = await ModelApiKeyService.create_api_key(db=db, api_key_data=api_key_data)
-        api_logger.info(f"模型API Key创建成功: {result.model_name} (ID: {result.id})")
+        result_orm = await ModelApiKeyService.create_api_key(db=db, api_key_data=api_key_data)
+        api_logger.info(f"模型API Key创建成功: {result_orm.model_name} (ID: {result_orm.id})")
+        result = model_schema.ModelApiKey.model_validate(result_orm)
        return success(data=result, msg="模型API Key创建成功")
    except Exception as e:
        api_logger.error(f"创建模型API Key失败: {api_key_data.model_name} - {str(e)}")
@@ -334,5 +601,3 @@ async def validate_model_config(
    return success(data=model_schema.ModelValidateResponse(**result), msg="验证完成")


-
-
--- a/api/app/controllers/public_share_controller.py
+++ b/api/app/controllers/public_share_controller.py
@@ -317,9 +317,12 @@ async def chat(
        appid = share.app_id
        """获取存储类型和工作空间的ID"""

-        # 直接通过 SQLAlchemy 查询 app
+        # 直接通过 SQLAlchemy 查询 app（仅查询未删除的应用）
        from app.models.app_model import App
-        app = db.query(App).filter(App.id == appid).first()
+        app = db.query(App).filter(
+            App.id == appid,
+            App.is_active.is_(True)
+        ).first()
        if not app:
            raise BusinessException("应用不存在", BizCode.APP_NOT_FOUND)

--- a/api/app/controllers/service/app_api_controller.py
+++ b/api/app/controllers/service/app_api_controller.py
@@ -235,11 +235,11 @@ async def chat(

                    message=payload.message,
                    conversation_id=conversation.id,  # 使用已创建的会话 ID
-                    user_id=new_end_user.id,  # 转换为字符串
+                    user_id=end_user_id,  # 转换为字符串
                    variables=payload.variables,
                    config=config,
-                    web_search=payload.web_search,
-                    memory=payload.memory,
+                    web_search=web_search,
+                    memory=memory,
                    storage_type=storage_type,
                    user_rag_memory_id=user_rag_memory_id,
                    app_id=app.id,
@@ -268,11 +268,11 @@ async def chat(

            message=payload.message,
            conversation_id=conversation.id,  # 使用已创建的会话 ID
-            user_id=new_end_user.id,  # 转换为字符串
+            user_id=end_user_id,  # 转换为字符串
            variables=payload.variables,
            config=config,
-            web_search=payload.web_search,
-            memory=payload.memory,
+            web_search=web_search,
+            memory=memory,
            storage_type=storage_type,
            user_rag_memory_id=user_rag_memory_id,
            app_id=app.id,
--- a/api/app/controllers/service/memory_api_controller.py
+++ b/api/app/controllers/service/memory_api_controller.py
@@ -39,7 +39,7 @@ async def write_memory_api_service(
    
    Stores memory content for the specified end user using the Memory API Service.
    """
-    logger.info(f"Memory write request - end_user_id: {payload.end_user_id}")
+    logger.info(f"Memory write request - end_user_id: {payload.end_user_id}, tenant_id: {api_key_auth.tenant_id}")
    
    memory_api_service = MemoryAPIService(db)
    
--- a/api/app/controllers/user_memory_controllers.py
+++ b/api/app/controllers/user_memory_controllers.py
@@ -135,27 +135,27 @@ async def generate_cache_api(
        api_logger.warning(f"用户 {current_user.username} 尝试生成缓存但未选择工作空间")
        return fail(BizCode.INVALID_PARAMETER, "请先切换到一个工作空间", "current_workspace_id is None")

-    group_id = request.end_user_id
+    end_user_id = request.end_user_id

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

    try:
-        if group_id:
+        if end_user_id:
            # 为单个用户生成
-            api_logger.info(f"开始为单个用户生成缓存: end_user_id={group_id}")
+            api_logger.info(f"开始为单个用户生成缓存: end_user_id={end_user_id}")

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

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

            # 构建响应
            result = {
-                "end_user_id": group_id,
+                "end_user_id": end_user_id,
                "insight_success": insight_result["success"],
                "summary_success": summary_result["success"],
                "errors": []
@@ -175,9 +175,9 @@ async def generate_cache_api(

            # 记录结果
            if result["insight_success"] and result["summary_success"]:
-                api_logger.info(f"成功为用户 {group_id} 生成缓存")
+                api_logger.info(f"成功为用户 {end_user_id} 生成缓存")
            else:
-                api_logger.warning(f"用户 {group_id} 的缓存生成部分失败: {result['errors']}")
+                api_logger.warning(f"用户 {end_user_id} 的缓存生成部分失败: {result['errors']}")

            return success(data=result, msg="生成完成")

--- a/api/app/controllers/workflow_controller.py
+++ b/api/app/controllers/workflow_controller.py
@@ -54,7 +54,7 @@ async def create_workflow_config(
        app = db.query(App).filter(
            App.id == app_id,
            App.workspace_id == current_user.current_workspace_id,
-            App.is_active == True
+            App.is_active.is_(True)
        ).first()

        if not app:
@@ -214,7 +214,7 @@ async def delete_workflow_config(
        app = db.query(App).filter(
            App.id == app_id,
            App.workspace_id == current_user.current_workspace_id,
-            App.is_active == True
+            App.is_active.is_(True)
        ).first()

        if not app:
@@ -259,7 +259,7 @@ async def validate_workflow_config(
        app = db.query(App).filter(
            App.id == app_id,
            App.workspace_id == current_user.current_workspace_id,
-            App.is_active == True
+            App.is_active.is_(True)
        ).first()

        if not app:
@@ -329,7 +329,7 @@ async def get_workflow_executions(
        app = db.query(App).filter(
            App.id == app_id,
            App.workspace_id == current_user.current_workspace_id,
-            App.is_active == True
+            App.is_active.is_(True)
        ).first()

        if not app:
@@ -389,7 +389,7 @@ async def get_workflow_execution(
        app = db.query(App).filter(
            App.id == execution.app_id,
            App.workspace_id == current_user.current_workspace_id,
-            App.is_active == True
+            App.is_active.is_(True)
        ).first()

        if not app:
@@ -440,7 +440,7 @@ async def run_workflow(
        app = db.query(App).filter(
            App.id == app_id,
            App.workspace_id == current_user.current_workspace_id,
-            App.is_active == True
+            App.is_active.is_(True)
        ).first()

        if not app:
@@ -578,7 +578,7 @@ async def cancel_workflow_execution(
        app = db.query(App).filter(
            App.id == execution.app_id,
            App.workspace_id == current_user.current_workspace_id,
-            App.is_active == True
+            App.is_active.is_(True)
        ).first()

        if not app: