Merge branch 'main-fix' into main

README.md

@@ -101,7 +101,7 @@
 
 <div align="center">
 <a href="https://www.bilibili.com/video/BV1amAneGE3P" target="_blank">
-    <img src="docs/video.png" width="300" alt="麦麦演示视频">
+    <img src="docs/pic/video.png" width="300" alt="麦麦演示视频">
     <br>
     👆 点击观看麦麦演示视频 👆
 
@@ -149,6 +149,8 @@ MaiMBot是一个开源项目，我们非常欢迎你的参与。你的贡献，
 
 - [📦 Linux 手动部署指南 ](docs/manual_deploy_linux.md)
 
+- [📦 macOS 手动部署指南 ](docs/manual_deploy_macos.md)
+
 如果你不知道Docker是什么，建议寻找相关教程或使用手动部署 **（现在不建议使用docker，更新慢，可能不适配）**
 
 - [🐳 Docker部署指南](docs/docker_deploy.md)

bot.py

@@ -204,8 +204,8 @@ def check_eula():
             eula_confirmed = True
             eula_updated = False
     if eula_new_hash == os.getenv("EULA_AGREE"):
-            eula_confirmed = True
+        eula_confirmed = True
-            eula_updated = False
+        eula_updated = False
 
     # 检查隐私条款确认文件是否存在
     if privacy_confirm_file.exists():
@@ -214,14 +214,16 @@ def check_eula():
         if privacy_new_hash == confirmed_content:
             privacy_confirmed = True
             privacy_updated = False
-    if privacy_new_hash  == os.getenv("PRIVACY_AGREE"):
+    if privacy_new_hash == os.getenv("PRIVACY_AGREE"):
-            privacy_confirmed = True
+        privacy_confirmed = True
-            privacy_updated = False
+        privacy_updated = False
 
     # 如果EULA或隐私条款有更新，提示用户重新确认
     if eula_updated or privacy_updated:
         print("EULA或隐私条款内容已更新，请在阅读后重新确认，继续运行视为同意更新后的以上两款协议")
-        print(f'输入"同意"或"confirmed"或设置环境变量"EULA_AGREE={eula_new_hash}"和"PRIVACY_AGREE={privacy_new_hash}"继续运行')
+        print(
+            f'输入"同意"或"confirmed"或设置环境变量"EULA_AGREE={eula_new_hash}"和"PRIVACY_AGREE={privacy_new_hash}"继续运行'
+        )
         while True:
             user_input = input().strip().lower()
             if user_input in ["同意", "confirmed"]:

docs/fast_q_a.md

@@ -10,7 +10,7 @@
 
 - 为什么显示:"缺失必要的API KEY" ❓
 
-<img src="API_KEY.png" width=650>
+<img src="./pic/API_KEY.png" width=650>
 
 >你需要在 [Silicon Flow Api](https://cloud.siliconflow.cn/account/ak) 网站上注册一个账号，然后点击这个链接打开API KEY获取页面。
 >
@@ -41,19 +41,19 @@
 
 >打开你的MongoDB Compass软件，你会在左上角看到这样的一个界面：
 >
-><img src="MONGO_DB_0.png" width=250>
+><img src="./pic/MONGO_DB_0.png" width=250>
 >
 ><br>
 >
 >点击 "CONNECT" 之后，点击展开 MegBot 标签栏
 >
-><img src="MONGO_DB_1.png" width=250>
+><img src="./pic/MONGO_DB_1.png" width=250>
 >
 ><br>
 >
 >点进 "emoji" 再点击 "DELETE" 删掉所有条目，如图所示
 >
-><img src="MONGO_DB_2.png" width=450>
+><img src="./pic/MONGO_DB_2.png" width=450>
 >
 ><br>
 >

docs/installation_cute.md

@@ -147,9 +147,7 @@ enable_check = false  # 是否要检查表情包是不是合适的喵
 check_prompt = "符合公序良俗"  # 检查表情包的标准呢
 
 [others]
-enable_advance_output = true # 是否要显示更多的运行信息呢
 enable_kuuki_read = true # 让机器人能够"察言观色"喵
-enable_debug_output = false # 是否启用调试输出喵
 enable_friend_chat = false # 是否启用好友聊天喵
 
 [groups]

docs/installation_standard.md

@@ -115,9 +115,7 @@ talk_frequency_down = []   # 降低回复频率的群号
 ban_user_id = []      # 禁止回复的用户QQ号
 
 [others]
-enable_advance_output = true # 是否启用高级输出
 enable_kuuki_read = true # 是否启用读空气功能
-enable_debug_output = false # 是否启用调试输出
 enable_friend_chat = false # 是否启用好友聊天
 
 # 模型配置

docs/linux_deploy_guide_for_beginners.md

@@ -1,48 +1,51 @@
 # 面向纯新手的Linux服务器麦麦部署指南
 
-## 你得先有一个服务器
 
-为了能使麦麦在你的电脑关机之后还能运行，你需要一台不间断开机的主机，也就是我们常说的服务器。
+## 事前准备
+为了能使麦麦不间断的运行，你需要一台一直开着的主机。
 
+### 如果你想购买服务器
 华为云、阿里云、腾讯云等等都是在国内可以选择的选择。
 
-你可以去租一台最低配置的就足敷需要了，按月租大概十几块钱就能租到了。
+租一台最低配置的就足敷需要了，按月租大概十几块钱就能租到了。
 
-我们假设你已经租好了一台Linux架构的云服务器。我用的是阿里云ubuntu24.04，其他的原理相似。
+### 如果你不想购买服务器
+你可以准备一台可以一直开着的电脑/主机，只需要保证能够正常访问互联网即可
+
+我们假设你已经有了一台Linux架构的服务器。举例使用的是Ubuntu24.04，其他的原理相似。
 
 ## 0.我们就从零开始吧
 
 ### 网络问题
 
-为访问github相关界面，推荐去下一款加速器，新手可以试试watttoolkit。
+为访问Github相关界面，推荐去下一款加速器，新手可以试试[Watt Toolkit](https://gitee.com/rmbgame/SteamTools/releases/latest)。
 
 ### 安装包下载
 
 #### MongoDB
+进入[MongoDB下载页](https://www.mongodb.com/try/download/community-kubernetes-operator)，并选择版本
 
-对于ubuntu24.04 x86来说是这个：
+以Ubuntu24.04 x86为例，保持如图所示选项，点击`Download`即可，如果是其他系统，请在`Platform`中自行选择：
 
-https://repo.mongodb.org/apt/ubuntu/dists/noble/mongodb-org/8.0/multiverse/binary-amd64/mongodb-org-server_8.0.5_amd64.deb
+![](./pic/MongoDB_Ubuntu_guide.png)
 
-如果不是就在这里自行选择对应版本
 
-https://www.mongodb.com/try/download/community-kubernetes-operator
+不想使用上述方式？你也可以参考[官方文档](https://www.mongodb.com/zh-cn/docs/manual/administration/install-on-linux/#std-label-install-mdb-community-edition-linux)进行安装，进入后选择自己的系统版本即可
 
-#### Napcat
+#### QQ（可选）/Napcat
-
+*如果你使用Napcat的脚本安装，可以忽略此步*
-在这里选择对应版本。
+访问https://github.com/NapNeko/NapCatQQ/releases/latest
-
+在图中所示区域可以找到QQ的下载链接，选择对应版本下载即可
-https://github.com/NapNeko/NapCatQQ/releases/tag/v4.6.7
+从这里下载，可以保证你下载到的QQ版本兼容最新版Napcat
-
+![](./pic/QQ_Download_guide_Linux.png)
-对于ubuntu24.04 x86来说是这个：
+如果你不想使用Napcat的脚本安装，还需参考[Napcat-Linux手动安装](https://www.napcat.wiki/guide/boot/Shell-Linux-SemiAuto)
-
-https://dldir1.qq.com/qqfile/qq/QQNT/ee4bd910/linuxqq_3.2.16-32793_amd64.deb
 
 #### 麦麦
 
-https://github.com/SengokuCola/MaiMBot/archive/refs/tags/0.5.8-alpha.zip
+先打开https://github.com/MaiM-with-u/MaiBot/releases
-
+往下滑找到这个
-下载这个官方压缩包。
+![下载指引](./pic/linux_beginner_downloadguide.png "")
+下载箭头所指这个压缩包。
 
 ### 路径
 
@@ -53,10 +56,10 @@ https://github.com/SengokuCola/MaiMBot/archive/refs/tags/0.5.8-alpha.zip
 ```
 moi
 └─ mai
-   ├─ linuxqq_3.2.16-32793_amd64.deb
+   ├─ linuxqq_3.2.16-32793_amd64.deb   # linuxqq安装包
-   ├─ mongodb-org-server_8.0.5_amd64.deb
+   ├─ mongodb-org-server_8.0.5_amd64.deb  # MongoDB的安装包
    └─ bot
-      └─ MaiMBot-0.5.8-alpha.zip
+      └─ MaiMBot-0.5.8-alpha.zip # 麦麦的压缩包
 ```
 
 ### 网络
@@ -69,7 +72,7 @@ moi
 
 ## 2. Python的安装
 
-- 导入 Python 的稳定版 PPA：
+- 导入 Python 的稳定版 PPA（Ubuntu需执行此步，Debian可忽略）：
 
 ```bash
 sudo add-apt-repository ppa:deadsnakes/ppa
@@ -92,6 +95,11 @@ sudo apt install python3.12
 ```bash
 python3.12 --version
 ```
+- （可选）更新替代方案，设置 python3.12 为默认的 python3 版本:
+```bash
+sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.12 1
+sudo update-alternatives --config python3
+```
 
 - 在「终端」中，执行以下命令安装 pip：
 
@@ -141,23 +149,17 @@ systemctl status mongod #通过这条指令检查运行状态
 sudo systemctl enable mongod
 ```
 
-## 5.napcat的安装
+## 5.Napcat的安装
 
 ``` bash
+# 该脚本适用于支持Ubuntu 20+/Debian 10+/Centos9
 curl -o napcat.sh https://nclatest.znin.net/NapNeko/NapCat-Installer/main/script/install.sh && sudo bash napcat.sh
 ```
-
+执行后，脚本会自动帮你部署好QQ及Napcat
-上面的不行试试下面的
-
-``` bash
-dpkg -i linuxqq_3.2.16-32793_amd64.deb
-apt-get install -f
-dpkg -i linuxqq_3.2.16-32793_amd64.deb
-```
 
 成功的标志是输入``` napcat ```出来炫酷的彩虹色界面
 
-## 6.napcat的运行
+## 6.Napcat的运行
 
 此时你就可以根据提示在```napcat```里面登录你的QQ号了。
 
@@ -170,6 +172,13 @@ napcat status #检查运行状态
 
 ```http://<你服务器的公网IP>:6099/webui?token=napcat```
 
+如果你部署在自己的电脑上：
+```http://127.0.0.1:6099/webui?token=napcat```
+
+> [!WARNING]
+> 如果你的麦麦部署在公网，请**务必**修改Napcat的默认密码
+
+
 第一次是这个，后续改了密码之后token就会对应修改。你也可以使用```napcat log <你的QQ号>```来查看webui地址。把里面的```127.0.0.1```改成<你服务器的公网IP>即可。
 
 登录上之后在网络配置界面添加websocket客户端，名称随便输一个，url改成`ws://127.0.0.1:8080/onebot/v11/ws`保存之后点启用，就大功告成了。
@@ -178,7 +187,7 @@ napcat status #检查运行状态
 
 ### step 1 安装解压软件
 
-```
+```bash
 sudo apt-get install unzip
 ```
 
@@ -229,138 +238,11 @@ bot
 
 你可以注册一个硅基流动的账号，通过邀请码注册有14块钱的免费额度：https://cloud.siliconflow.cn/i/7Yld7cfg。
 
-#### 在.env.prod中定义API凭证：
+#### 修改配置文件
+请参考
+- [🎀 新手配置指南](./installation_cute.md) - 通俗易懂的配置教程，适合初次使用的猫娘
+- [⚙️ 标准配置指南](./installation_standard.md) - 简明专业的配置说明，适合有经验的用户
 
-```
-# API凭证配置
-SILICONFLOW_KEY=your_key        # 硅基流动API密钥
-SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1/  # 硅基流动API地址
-
-DEEP_SEEK_KEY=your_key          # DeepSeek API密钥
-DEEP_SEEK_BASE_URL=https://api.deepseek.com/v1  # DeepSeek API地址
-
-CHAT_ANY_WHERE_KEY=your_key     # ChatAnyWhere API密钥
-CHAT_ANY_WHERE_BASE_URL=https://api.chatanywhere.tech/v1  # ChatAnyWhere API地址
-```
-
-#### 在bot_config.toml中引用API凭证：
-
-```
-[model.llm_reasoning]
-name = "Pro/deepseek-ai/DeepSeek-R1"
-base_url = "SILICONFLOW_BASE_URL"  # 引用.env.prod中定义的地址
-key = "SILICONFLOW_KEY"            # 引用.env.prod中定义的密钥
-```
-
-如需切换到其他API服务，只需修改引用：
-
-```
-[model.llm_reasoning]
-name = "Pro/deepseek-ai/DeepSeek-R1"
-base_url = "DEEP_SEEK_BASE_URL"  # 切换为DeepSeek服务
-key = "DEEP_SEEK_KEY"            # 使用DeepSeek密钥
-```
-
-#### 配置文件详解
-
-##### 环境配置文件 (.env.prod)
-
-```
-# API配置
-SILICONFLOW_KEY=your_key
-SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1/
-DEEP_SEEK_KEY=your_key
-DEEP_SEEK_BASE_URL=https://api.deepseek.com/v1
-CHAT_ANY_WHERE_KEY=your_key
-CHAT_ANY_WHERE_BASE_URL=https://api.chatanywhere.tech/v1
-
-# 服务配置
-HOST=127.0.0.1  # 如果使用Docker部署，需要改成0.0.0.0，否则QQ消息无法传入
-PORT=8080
-
-# 数据库配置
-MONGODB_HOST=127.0.0.1  # 如果使用Docker部署，需要改成数据库容器的名字，默认是mongodb
-MONGODB_PORT=27017
-DATABASE_NAME=MegBot
-MONGODB_USERNAME = ""  # 数据库用户名
-MONGODB_PASSWORD = ""  # 数据库密码
-MONGODB_AUTH_SOURCE = ""  # 认证数据库
-
-# 插件配置
-PLUGINS=["src2.plugins.chat"]
-```
-
-##### 机器人配置文件 (bot_config.toml)
-
-```
-[bot]
-qq = "机器人QQ号"  # 必填
-nickname = "麦麦"  # 机器人昵称（你希望机器人怎么称呼它自己）
-
-[personality]
-prompt_personality = [
-    "曾经是一个学习地质的女大学生，现在学习心理学和脑科学，你会刷贴吧",
-    "是一个女大学生，你有黑色头发，你会刷小红书"
-]
-prompt_schedule = "一个曾经学习地质,现在学习心理学和脑科学的女大学生，喜欢刷qq，贴吧，知乎和小红书"
-
-[message]
-min_text_length = 2  # 最小回复长度
-max_context_size = 15  # 上下文记忆条数
-emoji_chance = 0.2  # 表情使用概率
-ban_words = []  # 禁用词列表
-
-[emoji]
-auto_save = true  # 自动保存表情
-enable_check = false  # 启用表情审核
-check_prompt = "符合公序良俗"
-
-[groups]
-talk_allowed = []      # 允许对话的群号
-talk_frequency_down = []   # 降低回复频率的群号
-ban_user_id = []      # 禁止回复的用户QQ号
-
-[others]
-enable_advance_output = true  # 启用详细日志
-enable_kuuki_read = true  # 启用场景理解
-
-# 模型配置
-[model.llm_reasoning]  # 推理模型
-name = "Pro/deepseek-ai/DeepSeek-R1"
-base_url = "SILICONFLOW_BASE_URL"
-key = "SILICONFLOW_KEY"
-
-[model.llm_reasoning_minor]  # 轻量推理模型
-name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
-base_url = "SILICONFLOW_BASE_URL"
-key = "SILICONFLOW_KEY"
-
-[model.llm_normal]  # 对话模型
-name = "Pro/deepseek-ai/DeepSeek-V3"
-base_url = "SILICONFLOW_BASE_URL"
-key = "SILICONFLOW_KEY"
-
-[model.llm_normal_minor]  # 备用对话模型
-name = "deepseek-ai/DeepSeek-V2.5"
-base_url = "SILICONFLOW_BASE_URL"
-key = "SILICONFLOW_KEY"
-
-[model.vlm]  # 图像识别模型
-name = "deepseek-ai/deepseek-vl2"
-base_url = "SILICONFLOW_BASE_URL"
-key = "SILICONFLOW_KEY"
-
-[model.embedding]  # 文本向量模型
-name = "BAAI/bge-m3"
-base_url = "SILICONFLOW_BASE_URL"
-key = "SILICONFLOW_KEY"
-
-
-[topic.llm_topic]
-name = "Pro/deepseek-ai/DeepSeek-V3"
-base_url = "SILICONFLOW_BASE_URL"
-key = "SILICONFLOW_KEY"
-```
 
 **step # 6** 运行
 
@@ -438,7 +320,7 @@ sudo systemctl enable bot.service # 启动bot服务
 sudo systemctl status bot.service # 检查bot服务状态
 ```
 
-```
+```bash
-python bot.py
+python bot.py  # 运行麦麦
 ```
 

docs/manual_deploy_linux.md

@@ -6,7 +6,7 @@
 - QQ小号（QQ框架的使用可能导致qq被风控，严重（小概率）可能会导致账号封禁，强烈不推荐使用大号）
 - 可用的大模型API
 - 一个AI助手，网上随便搜一家打开来用都行，可以帮你解决一些不懂的问题
-- 以下内容假设你对Linux系统有一定的了解，如果觉得难以理解，请直接用Windows系统部署[Windows系统部署指南](./manual_deploy_windows.md)
+- 以下内容假设你对Linux系统有一定的了解，如果觉得难以理解，请直接用Windows系统部署[Windows系统部署指南](./manual_deploy_windows.md)或[使用Windows一键包部署](https://github.com/MaiM-with-u/MaiBot/releases/tag/EasyInstall-windows)
 
 ## 你需要知道什么？
 
@@ -24,6 +24,9 @@
 
 ---
 
+## 一键部署
+请下载并运行项目根目录中的run.sh并按照提示安装，部署完成后请参照后续配置指南进行配置
+
 ## 环境配置
 
 ### 1️⃣ **确认Python版本**
@@ -36,17 +39,26 @@ python --version
 python3 --version
 ```
 
-如果版本低于3.9，请更新Python版本。
+如果版本低于3.9，请更新Python版本，目前建议使用python3.12
 
 ```bash
-# Ubuntu/Debian
+# Debian
 sudo apt update
-sudo apt install python3.9
+sudo apt install python3.12
-# 如执行了这一步，建议在执行时将python3指向python3.9
+# Ubuntu
-# 更新替代方案，设置 python3.9 为默认的 python3 版本:
+sudo add-apt-repository ppa:deadsnakes/ppa
-sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.9 1
+sudo apt update
+sudo apt install python3.12
+
+# 执行完以上命令后，建议在执行时将python3指向python3.12
+# 更新替代方案，设置 python3.12 为默认的 python3 版本:
+sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.12 1
 sudo update-alternatives --config python3
 ```
+建议再执行以下命令，使后续运行命令中的`python3`等同于`python`
+```bash
+sudo apt install python-is-python3
+```
 
 ### 2️⃣ **创建虚拟环境**
 
@@ -73,7 +85,7 @@ pip install -r requirements.txt
 
 ### 3️⃣ **安装并启动MongoDB**
 
-- 安装与启动：Debian参考[官方文档](https://docs.mongodb.com/manual/tutorial/install-mongodb-on-debian/)，Ubuntu参考[官方文档](https://docs.mongodb.com/manual/tutorial/install-mongodb-on-ubuntu/)
+- 安装与启动：请参考[官方文档](https://www.mongodb.com/zh-cn/docs/manual/administration/install-on-linux/#std-label-install-mdb-community-edition-linux)，进入后选择自己的系统版本即可
 - 默认连接本地27017端口
 
 ---
@@ -82,7 +94,11 @@ pip install -r requirements.txt
 
 ### 4️⃣ **安装NapCat框架**
 
-- 参考[NapCat官方文档](https://www.napcat.wiki/guide/boot/Shell#napcat-installer-linux%E4%B8%80%E9%94%AE%E4%BD%BF%E7%94%A8%E8%84%9A%E6%9C%AC-%E6%94%AF%E6%8C%81ubuntu-20-debian-10-centos9)安装
+- 执行NapCat的Linux一键使用脚本(支持Ubuntu 20+/Debian 10+/Centos9) 
+```bash
+curl -o napcat.sh https://nclatest.znin.net/NapNeko/NapCat-Installer/main/script/install.sh && sudo bash napcat.sh
+```
+- 如果你不想使用Napcat的脚本安装，可参考[Napcat-Linux手动安装](https://www.napcat.wiki/guide/boot/Shell-Linux-SemiAuto)
 
 -  使用QQ小号登录，添加反向WS地址: `ws://127.0.0.1:8080/onebot/v11/ws`
 
@@ -91,9 +107,17 @@ pip install -r requirements.txt
 ## 配置文件设置
 
 ### 5️⃣ **配置文件设置，让麦麦Bot正常工作**
-
+可先运行一次
-- 修改环境配置文件：`.env.prod`
+```bash
-- 修改机器人配置文件：`bot_config.toml`
+# 在项目目录下操作
+nb run
+# 或
+python3 bot.py
+```
+之后你就可以找到`.env.prod`和`bot_config.toml`这两个文件了
+关于文件内容的配置请参考：
+- [🎀 新手配置指南](./installation_cute.md) - 通俗易懂的配置教程，适合初次使用的猫娘
+- [⚙️ 标准配置指南](./installation_standard.md) - 简明专业的配置说明，适合有经验的用户
 
 ---
 

docs/manual_deploy_macos.md

@@ -0,0 +1,201 @@
+# 📦 macOS系统手动部署MaiMbot麦麦指南
+
+## 准备工作
+
+- 一台搭载了macOS系统的设备（macOS 12.0 或以上）
+- QQ小号（QQ框架的使用可能导致qq被风控，严重（小概率）可能会导致账号封禁，强烈不推荐使用大号）
+- Homebrew包管理器
+    - 如未安装，你可以在https://github.com/Homebrew/brew/releases/latest 找到.pkg格式的安装包
+- 可用的大模型API
+- 一个AI助手，网上随便搜一家打开来用都行，可以帮你解决一些不懂的问题
+- 以下内容假设你对macOS系统有一定的了解，如果觉得难以理解，请直接用Windows系统部署[Windows系统部署指南](./manual_deploy_windows.md)或[使用Windows一键包部署](https://github.com/MaiM-with-u/MaiBot/releases/tag/EasyInstall-windows)
+- 终端应用（iTerm2等）
+
+---
+
+## 环境配置
+
+### 1️⃣ **Python环境配置**
+
+```bash
+# 检查Python版本（macOS自带python可能为2.7）
+python3 --version
+
+# 通过Homebrew安装Python
+brew install python@3.12
+
+# 设置环境变量（如使用zsh）
+echo 'export PATH="/usr/local/opt/python@3.12/bin:$PATH"' >> ~/.zshrc
+source ~/.zshrc
+
+# 验证安装
+python3 --version  # 应显示3.12.x
+pip3 --version     # 应关联3.12版本
+```
+
+### 2️⃣ **创建虚拟环境**
+
+```bash
+# 方法1：使用venv（推荐）
+python3 -m venv maimbot-venv
+source maimbot-venv/bin/activate    # 激活虚拟环境
+
+# 方法2：使用conda
+brew install --cask miniconda
+conda create -n maimbot python=3.9
+conda activate maimbot  # 激活虚拟环境
+
+# 安装项目依赖
+# 请确保已经进入虚拟环境再执行
+pip install -r requirements.txt
+```
+
+---
+
+## 数据库配置
+
+### 3️⃣ **安装MongoDB**
+
+请参考[官方文档](https://www.mongodb.com/zh-cn/docs/manual/tutorial/install-mongodb-on-os-x/#install-mongodb-community-edition)
+
+---
+
+## NapCat
+
+### 4️⃣ **安装与配置Napcat**
+- 安装
+可以使用Napcat官方提供的[macOS安装工具](https://github.com/NapNeko/NapCat-Mac-Installer/releases/)
+由于权限问题，补丁过程需要手动替换 package.json，请注意备份原文件～
+- 配置
+使用QQ小号登录，添加反向WS地址: `ws://127.0.0.1:8080/onebot/v11/ws`
+
+---
+
+## 配置文件设置
+
+### 5️⃣ **生成配置文件**
+可先运行一次
+```bash
+# 在项目目录下操作
+nb run
+# 或
+python3 bot.py
+```
+
+之后你就可以找到`.env.prod`和`bot_config.toml`这两个文件了
+
+关于文件内容的配置请参考：
+- [🎀 新手配置指南](./installation_cute.md) - 通俗易懂的配置教程，适合初次使用的猫娘
+- [⚙️ 标准配置指南](./installation_standard.md) - 简明专业的配置说明，适合有经验的用户
+
+
+---
+
+## 启动机器人
+
+### 6️⃣ **启动麦麦机器人**
+
+```bash
+# 在项目目录下操作
+nb run
+# 或
+python3 bot.py
+```
+
+## 启动管理
+
+### 7️⃣ **通过launchd管理服务**
+
+创建plist文件：
+
+```bash
+nano ~/Library/LaunchAgents/com.maimbot.plist
+```
+
+内容示例（需替换实际路径）：
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.maimbot</string>
+    
+    <key>ProgramArguments</key>
+    <array>
+        <string>/path/to/maimbot-venv/bin/python</string>
+        <string>/path/to/MaiMbot/bot.py</string>
+    </array>
+    
+    <key>WorkingDirectory</key>
+    <string>/path/to/MaiMbot</string>
+    
+    <key>StandardOutPath</key>
+    <string>/tmp/maimbot.log</string>
+    <key>StandardErrorPath</key>
+    <string>/tmp/maimbot.err</string>
+    
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+</dict>
+</plist>
+```
+
+加载服务：
+
+```bash
+launchctl load ~/Library/LaunchAgents/com.maimbot.plist
+launchctl start com.maimbot
+```
+
+查看日志：
+
+```bash
+tail -f /tmp/maimbot.log
+```
+
+---
+
+## 常见问题处理
+
+1. **权限问题**
+```bash
+# 遇到文件权限错误时
+chmod -R 755 ~/Documents/MaiMbot
+```
+
+2. **Python模块缺失**
+```bash
+# 确保在虚拟环境中
+source maimbot-venv/bin/activate  # 或 conda 激活
+pip install --force-reinstall -r requirements.txt
+```
+
+3. **MongoDB连接失败**
+```bash
+# 检查服务状态
+brew services list
+# 重置数据库权限
+mongosh --eval "db.adminCommand({setFeatureCompatibilityVersion: '5.0'})"
+```
+
+---
+
+## 系统优化建议
+
+1. **关闭App Nap**
+```bash
+# 防止系统休眠NapCat进程
+defaults write NSGlobalDomain NSAppSleepDisabled -bool YES
+```
+
+2. **电源管理设置**
+```bash
+# 防止睡眠影响机器人运行
+sudo systemsetup -setcomputersleep Never
+```
+
+---

docs/synology_deploy.md

@@ -16,7 +16,7 @@
 
 docker-compose.yml: https://github.com/SengokuCola/MaiMBot/blob/main/docker-compose.yml
 下载后打开，将 `services-mongodb-image` 修改为 `mongo:4.4.24`。这是因为最新的 MongoDB 强制要求 AVX 指令集，而群晖似乎不支持这个指令集
-![](https://raw.githubusercontent.com/ProperSAMA/MaiMBot/refs/heads/debug/docs/synology_docker-compose.png)
+![](./pic/synology_docker-compose.png)
 
 bot_config.toml: https://github.com/SengokuCola/MaiMBot/blob/main/template/bot_config_template.toml
 下载后，重命名为 `bot_config.toml`
@@ -26,13 +26,13 @@ bot_config.toml: https://github.com/SengokuCola/MaiMBot/blob/main/template/bot_c
 下载后，重命名为 `.env.prod`
 将 `HOST` 修改为 `0.0.0.0`，确保 maimbot 能被 napcat 访问
 按下图修改 mongodb 设置，使用  `MONGODB_URI`
-![](https://raw.githubusercontent.com/ProperSAMA/MaiMBot/refs/heads/debug/docs/synology_.env.prod.png)
+![](./pic/synology_.env.prod.png)
 
 把 `bot_config.toml` 和 `.env.prod` 放入之前创建的 `MaiMBot`文件夹
 
 #### 如何下载？
 
-点这里！![](https://raw.githubusercontent.com/ProperSAMA/MaiMBot/refs/heads/debug/docs/synology_how_to_download.png)
+点这里！![](./pic/synology_how_to_download.png)
 
 ### 创建项目
 
@@ -45,7 +45,7 @@ bot_config.toml: https://github.com/SengokuCola/MaiMBot/blob/main/template/bot_c
 
 图例：
 
-![](https://raw.githubusercontent.com/ProperSAMA/MaiMBot/refs/heads/debug/docs/synology_create_project.png)
+![](./pic/synology_create_project.png)
 
 一路点下一步，等待项目创建完成
 

src/common/logger.py

@@ -31,9 +31,10 @@ _handler_registry: Dict[str, List[int]] = {}
 current_file_path = Path(__file__).resolve()
 LOG_ROOT = "logs"
 
-ENABLE_ADVANCE_OUTPUT = False
+SIMPLE_OUTPUT = os.getenv("SIMPLE_OUTPUT", "false")
+print(f"SIMPLE_OUTPUT: {SIMPLE_OUTPUT}")
 
-if ENABLE_ADVANCE_OUTPUT:
+if not SIMPLE_OUTPUT:
     # 默认全局配置
     DEFAULT_CONFIG = {
         # 日志级别配置
@@ -85,7 +86,6 @@ MEMORY_STYLE_CONFIG = {
     },
 }
 
-# 海马体日志样式配置
 SENDER_STYLE_CONFIG = {
     "advanced": {
         "console_format": (
@@ -152,17 +152,17 @@ CHAT_STYLE_CONFIG = {
         "file_format": ("{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 见闻 | {message}"),
     },
     "simple": {
-        "console_format": ("<green>{time:MM-DD HH:mm}</green> | <light-blue>见闻</light-blue> | {message}"),
+        "console_format": ("<green>{time:MM-DD HH:mm}</green> | <light-blue>见闻</light-blue> | <green>{message}</green>"),  # noqa: E501
         "file_format": ("{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 见闻 | {message}"),
     },
 }
 
-# 根据ENABLE_ADVANCE_OUTPUT选择配置
+# 根据SIMPLE_OUTPUT选择配置
-MEMORY_STYLE_CONFIG = MEMORY_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else MEMORY_STYLE_CONFIG["simple"]
+MEMORY_STYLE_CONFIG = MEMORY_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else MEMORY_STYLE_CONFIG["advanced"]
-TOPIC_STYLE_CONFIG = TOPIC_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else TOPIC_STYLE_CONFIG["simple"]
+TOPIC_STYLE_CONFIG = TOPIC_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else TOPIC_STYLE_CONFIG["advanced"]  
-SENDER_STYLE_CONFIG = SENDER_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else SENDER_STYLE_CONFIG["simple"]
+SENDER_STYLE_CONFIG = SENDER_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else SENDER_STYLE_CONFIG["advanced"]
-LLM_STYLE_CONFIG = LLM_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else LLM_STYLE_CONFIG["simple"]
+LLM_STYLE_CONFIG = LLM_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else LLM_STYLE_CONFIG["advanced"]
-CHAT_STYLE_CONFIG = CHAT_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else CHAT_STYLE_CONFIG["simple"]
+CHAT_STYLE_CONFIG = CHAT_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else CHAT_STYLE_CONFIG["advanced"]
 
 
 def is_registered_module(record: dict) -> bool:

src/plugins/chat/__init__.py

@@ -92,12 +92,13 @@ async def _(bot: Bot):
 
 @msg_in.handle()
 async def _(bot: Bot, event: MessageEvent, state: T_State):
-    #处理合并转发消息
+    # 处理合并转发消息
     if "forward" in event.message:
-        await chat_bot.handle_forward_message(event , bot)
+        await chat_bot.handle_forward_message(event, bot)
-    else :
+    else:
         await chat_bot.handle_message(event, bot)
 
+
 @notice_matcher.handle()
 async def _(bot: Bot, event: NoticeEvent, state: T_State):
     logger.debug(f"收到通知：{event}")
@@ -110,7 +111,7 @@ async def build_memory_task():
     """每build_memory_interval秒执行一次记忆构建"""
     logger.debug("[记忆构建]------------------------------------开始构建记忆--------------------------------------")
     start_time = time.time()
-    await hippocampus.operation_build_memory(chat_size=20)
+    await hippocampus.operation_build_memory()
     end_time = time.time()
     logger.success(
         f"[记忆构建]--------------------------记忆构建完成：耗时: {end_time - start_time:.2f} "

src/plugins/chat/bot.py

@@ -154,7 +154,7 @@ class ChatBot:
             )
             # 开始思考的时间点
             thinking_time_point = round(time.time(), 2)
-            logger.info(f"开始思考的时间点: {thinking_time_point}")
+            # logger.debug(f"开始思考的时间点: {thinking_time_point}")
             think_id = "mt" + str(thinking_time_point)
             thinking_message = MessageThinking(
                 message_id=think_id,
@@ -418,13 +418,12 @@ class ChatBot:
         # 用户屏蔽,不区分私聊/群聊
         if event.user_id in global_config.ban_user_id:
             return
-        
+
         if isinstance(event, GroupMessageEvent):
             if event.group_id:
                 if event.group_id not in global_config.talk_allowed_groups:
                     return
 
-
         # 获取合并转发消息的详细信息
         forward_info = await bot.get_forward_msg(message_id=event.message_id)
         messages = forward_info["messages"]
@@ -434,17 +433,17 @@ class ChatBot:
         for node in messages:
             # 提取发送者昵称
             nickname = node["sender"].get("nickname", "未知用户")
-            
+
             # 递归处理消息内容
-            message_content = await self.process_message_segments(node["message"],layer=0)
+            message_content = await self.process_message_segments(node["message"], layer=0)
-            
+
             # 拼接为【昵称】+ 内容
             processed_messages.append(f"【{nickname}】{message_content}")
 
         # 组合所有消息
         combined_message = "\n".join(processed_messages)
         combined_message = f"合并转发消息内容：\n{combined_message}"
-        
+
         # 构建用户信息（使用转发消息的发送者）
         user_info = UserInfo(
             user_id=event.user_id,
@@ -456,11 +455,7 @@ class ChatBot:
         # 构建群聊信息（如果是群聊）
         group_info = None
         if isinstance(event, GroupMessageEvent):
-            group_info = GroupInfo(
+            group_info = GroupInfo(group_id=event.group_id, group_name=None, platform="qq")
-                group_id=event.group_id,
-                group_name=None,
-                platform="qq"
-            )
 
         # 创建消息对象
         message_cq = MessageRecvCQ(
@@ -475,19 +470,19 @@ class ChatBot:
         # 进入标准消息处理流程
         await self.message_process(message_cq)
 
-    async def process_message_segments(self, segments: list,layer:int) -> str:
+    async def process_message_segments(self, segments: list, layer: int) -> str:
         """递归处理消息段"""
         parts = []
         for seg in segments:
-            part = await self.process_segment(seg,layer+1)
+            part = await self.process_segment(seg, layer + 1)
             parts.append(part)
         return "".join(parts)
 
-    async def process_segment(self, seg: dict , layer:int) -> str:
+    async def process_segment(self, seg: dict, layer: int) -> str:
         """处理单个消息段"""
         seg_type = seg["type"]
-        if layer > 3 :
+        if layer > 3:
-            #防止有那种100层转发消息炸飞麦麦
+            # 防止有那种100层转发消息炸飞麦麦
             return "【转发消息】"
         if seg_type == "text":
             return seg["data"]["text"]
@@ -504,13 +499,14 @@ class ChatBot:
             nested_messages.append("合并转发消息内容：")
             for node in nested_nodes:
                 nickname = node["sender"].get("nickname", "未知用户")
-                content = await self.process_message_segments(node["message"],layer=layer)
+                content = await self.process_message_segments(node["message"], layer=layer)
                 # nested_messages.append('-' * layer)
                 nested_messages.append(f"{'--' * layer}【{nickname}】{content}")
             # nested_messages.append(f"{'--' * layer}合并转发第【{layer}】层结束")
             return "\n".join(nested_messages)
         else:
             return f"[{seg_type}]"
-        
+
+
 # 创建全局ChatBot实例
 chat_bot = ChatBot()

src/plugins/chat/config.py

@@ -56,7 +56,6 @@ class BotConfig:
     llm_reasoning: Dict[str, str] = field(default_factory=lambda: {})
     llm_reasoning_minor: Dict[str, str] = field(default_factory=lambda: {})
     llm_normal: Dict[str, str] = field(default_factory=lambda: {})
-    llm_normal_minor: Dict[str, str] = field(default_factory=lambda: {})
     llm_topic_judge: Dict[str, str] = field(default_factory=lambda: {})
     llm_summary_by_topic: Dict[str, str] = field(default_factory=lambda: {})
     llm_emotion_judge: Dict[str, str] = field(default_factory=lambda: {})
@@ -68,9 +67,9 @@ class BotConfig:
     MODEL_V3_PROBABILITY: float = 0.1  # V3模型概率
     MODEL_R1_DISTILL_PROBABILITY: float = 0.1  # R1蒸馏模型概率
 
-    enable_advance_output: bool = False  # 是否启用高级输出
+    # enable_advance_output: bool = False  # 是否启用高级输出
     enable_kuuki_read: bool = True  # 是否启用读空气功能
-    enable_debug_output: bool = False  # 是否启用调试输出
+    # enable_debug_output: bool = False  # 是否启用调试输出
     enable_friend_chat: bool = False  # 是否启用好友聊天
 
     mood_update_interval: float = 1.0  # 情绪更新间隔 单位秒
@@ -106,6 +105,11 @@ class BotConfig:
     memory_forget_time: int = 24  # 记忆遗忘时间（小时）
     memory_forget_percentage: float = 0.01  # 记忆遗忘比例
     memory_compress_rate: float = 0.1  # 记忆压缩率
+    build_memory_sample_num: int = 10  # 记忆构建采样数量
+    build_memory_sample_length: int = 20  # 记忆构建采样长度
+    memory_build_distribution: list = field(
+        default_factory=lambda: [4,2,0.6,24,8,0.4]
+    )  # 记忆构建分布，参数：分布1均值，标准差，权重，分布2均值，标准差，权重
     memory_ban_words: list = field(
         default_factory=lambda: ["表情包", "图片", "回复", "聊天记录"]
     )  # 添加新的配置项默认值
@@ -230,7 +234,6 @@ class BotConfig:
                 "llm_reasoning",
                 "llm_reasoning_minor",
                 "llm_normal",
-                "llm_normal_minor",
                 "llm_topic_judge",
                 "llm_summary_by_topic",
                 "llm_emotion_judge",
@@ -315,6 +318,20 @@ class BotConfig:
                     "memory_forget_percentage", config.memory_forget_percentage
                 )
                 config.memory_compress_rate = memory_config.get("memory_compress_rate", config.memory_compress_rate)
+            if config.INNER_VERSION in SpecifierSet(">=0.0.11"):
+                config.memory_build_distribution = memory_config.get(
+                    "memory_build_distribution", 
+                    config.memory_build_distribution
+                )
+                config.build_memory_sample_num = memory_config.get(
+                    "build_memory_sample_num", 
+                    config.build_memory_sample_num
+                )
+                config.build_memory_sample_length = memory_config.get(
+                    "build_memory_sample_length", 
+                    config.build_memory_sample_length
+                )
+
 
         def remote(parent: dict):
             remote_config = parent["remote"]
@@ -351,10 +368,10 @@ class BotConfig:
 
         def others(parent: dict):
             others_config = parent["others"]
-            config.enable_advance_output = others_config.get("enable_advance_output", config.enable_advance_output)
+            # config.enable_advance_output = others_config.get("enable_advance_output", config.enable_advance_output)
             config.enable_kuuki_read = others_config.get("enable_kuuki_read", config.enable_kuuki_read)
             if config.INNER_VERSION in SpecifierSet(">=0.0.7"):
-                config.enable_debug_output = others_config.get("enable_debug_output", config.enable_debug_output)
+                # config.enable_debug_output = others_config.get("enable_debug_output", config.enable_debug_output)
                 config.enable_friend_chat = others_config.get("enable_friend_chat", config.enable_friend_chat)
 
         # 版本表达式：>=1.0.0,<2.0.0

src/plugins/chat/emoji_manager.py

@@ -38,9 +38,9 @@ class EmojiManager:
 
     def __init__(self):
         self._scan_task = None
-        self.vlm = LLM_request(model=global_config.vlm, temperature=0.3, max_tokens=1000, request_type="image")
+        self.vlm = LLM_request(model=global_config.vlm, temperature=0.3, max_tokens=1000, request_type="emoji")
         self.llm_emotion_judge = LLM_request(
-            model=global_config.llm_emotion_judge, max_tokens=600, temperature=0.8, request_type="image"
+            model=global_config.llm_emotion_judge, max_tokens=600, temperature=0.8, request_type="emoji"
         )  # 更高的温度，更少的token（后续可以根据情绪来调整温度）
 
     def _ensure_emoji_dir(self):
@@ -111,7 +111,7 @@ class EmojiManager:
             if not text_for_search:
                 logger.error("无法获取文本的情绪")
                 return None
-            text_embedding = await get_embedding(text_for_search)
+            text_embedding = await get_embedding(text_for_search, request_type="emoji")
             if not text_embedding:
                 logger.error("无法获取文本的embedding")
                 return None
@@ -242,7 +242,33 @@ class EmojiManager:
                 image_hash = hashlib.md5(image_bytes).hexdigest()
                 image_format = Image.open(io.BytesIO(image_bytes)).format.lower()
                 # 检查是否已经注册过
-                existing_emoji = db["emoji"].find_one({"hash": image_hash})
+                existing_emoji_by_path = db["emoji"].find_one({"filename": filename})
+                existing_emoji_by_hash = db["emoji"].find_one({"hash": image_hash})
+                if existing_emoji_by_path and existing_emoji_by_hash:
+                    if existing_emoji_by_path["_id"] != existing_emoji_by_hash["_id"]:
+                        logger.error(f"[错误] 表情包已存在但记录不一致: {filename}")
+                        db.emoji.delete_one({"_id": existing_emoji_by_path["_id"]})
+                        db.emoji.update_one(
+                            {"_id": existing_emoji_by_hash["_id"]}, {"$set": {"path": image_path, "filename": filename}}
+                        )
+                        existing_emoji_by_hash["path"] = image_path
+                        existing_emoji_by_hash["filename"] = filename
+                    existing_emoji = existing_emoji_by_hash
+                elif existing_emoji_by_hash:
+                    logger.error(f"[错误] 表情包hash已存在但path不存在: {filename}")
+                    db.emoji.update_one(
+                        {"_id": existing_emoji_by_hash["_id"]}, {"$set": {"path": image_path, "filename": filename}}
+                    )
+                    existing_emoji_by_hash["path"] = image_path
+                    existing_emoji_by_hash["filename"] = filename
+                    existing_emoji = existing_emoji_by_hash
+                elif existing_emoji_by_path:
+                    logger.error(f"[错误] 表情包path已存在但hash不存在: {filename}")
+                    db.emoji.delete_one({"_id": existing_emoji_by_path["_id"]})
+                    existing_emoji = None
+                else:
+                    existing_emoji = None
+
                 description = None
 
                 if existing_emoji:
@@ -284,7 +310,7 @@ class EmojiManager:
                     logger.info(f"[检查] 表情包检查通过: {check}")
 
                 if description is not None:
-                    embedding = await get_embedding(description)
+                    embedding = await get_embedding(description, request_type="emoji")
                     # 准备数据库记录
                     emoji_record = {
                         "filename": filename,
@@ -366,6 +392,12 @@ class EmojiManager:
                         logger.warning(f"[检查] 发现缺失记录（缺少hash字段），ID: {emoji.get('_id', 'unknown')}")
                         hash = hashlib.md5(open(emoji["path"], "rb").read()).hexdigest()
                         db.emoji.update_one({"_id": emoji["_id"]}, {"$set": {"hash": hash}})
+                    else:
+                        file_hash = hashlib.md5(open(emoji["path"], "rb").read()).hexdigest()
+                        if emoji["hash"] != file_hash:
+                            logger.warning(f"[检查] 表情包文件hash不匹配，ID: {emoji.get('_id', 'unknown')}")
+                            db.emoji.delete_one({"_id": emoji["_id"]})
+                            removed_count += 1
 
                 except Exception as item_error:
                     logger.error(f"[错误] 处理表情包记录时出错: {str(item_error)}")

src/plugins/chat/llm_generator.py

@@ -32,11 +32,19 @@ class ResponseGenerator:
             temperature=0.7,
             max_tokens=1000,
             stream=True,
+            request_type="response",
+        )
+        self.model_v3 = LLM_request(
+            model=global_config.llm_normal, temperature=0.7, max_tokens=3000, request_type="response"
+        )
+        self.model_r1_distill = LLM_request(
+            model=global_config.llm_reasoning_minor, temperature=0.7, max_tokens=3000, request_type="response"
+        )
+        self.model_sum = LLM_request(
+            model=global_config.llm_summary_by_topic, temperature=0.7, max_tokens=3000, request_type="relation"
         )
-        self.model_v3 = LLM_request(model=global_config.llm_normal, temperature=0.7, max_tokens=3000)
-        self.model_r1_distill = LLM_request(model=global_config.llm_reasoning_minor, temperature=0.7, max_tokens=3000)
-        self.model_v25 = LLM_request(model=global_config.llm_normal_minor, temperature=0.7, max_tokens=3000)
         self.current_model_type = "r1"  # 默认使用 R1
+        self.current_model_name = "unknown model"
 
     async def generate_response(self, message: MessageThinking) -> Optional[Union[str, List[str]]]:
         """根据当前模型类型选择对应的生成函数"""
@@ -107,7 +115,7 @@ class ResponseGenerator:
 
         # 生成回复
         try:
-            content, reasoning_content = await model.generate_response(prompt)
+            content, reasoning_content, self.current_model_name = await model.generate_response(prompt)
         except Exception:
             logger.exception("生成回复时出错")
             return None
@@ -144,7 +152,7 @@ class ResponseGenerator:
                 "chat_id": message.chat_stream.stream_id,
                 "user": sender_name,
                 "message": message.processed_plain_text,
-                "model": self.current_model_type,
+                "model": self.current_model_name,
                 # 'reasoning_check': reasoning_content_check,
                 # 'response_check': content_check,
                 "reasoning": reasoning_content,
@@ -174,7 +182,7 @@ class ResponseGenerator:
             """
 
             # 调用模型生成结果
-            result, _ = await self.model_v25.generate_response(prompt)
+            result, _, _ = await self.model_sum.generate_response(prompt)
             result = result.strip()
 
             # 解析模型输出的结果
@@ -215,7 +223,7 @@ class InitiativeMessageGenerate:
         topic_select_prompt, dots_for_select, prompt_template = prompt_builder._build_initiative_prompt_select(
             message.group_id
         )
-        content_select, reasoning = self.model_v3.generate_response(topic_select_prompt)
+        content_select, reasoning, _ = self.model_v3.generate_response(topic_select_prompt)
         logger.debug(f"{content_select} {reasoning}")
         topics_list = [dot[0] for dot in dots_for_select]
         if content_select:
@@ -226,7 +234,7 @@ class InitiativeMessageGenerate:
         else:
             return None
         prompt_check, memory = prompt_builder._build_initiative_prompt_check(select_dot[1], prompt_template)
-        content_check, reasoning_check = self.model_v3.generate_response(prompt_check)
+        content_check, reasoning_check, _ = self.model_v3.generate_response(prompt_check)
         logger.info(f"{content_check} {reasoning_check}")
         if "yes" not in content_check.lower():
             return None

src/plugins/chat/message_sender.py

@@ -220,7 +220,7 @@ class MessageManager:
 
             message_timeout = container.get_timeout_messages()
             if message_timeout:
-                logger.warning(f"发现{len(message_timeout)}条超时消息")
+                logger.debug(f"发现{len(message_timeout)}条超时消息")
                 for msg in message_timeout:
                     if msg == message_earliest:
                         continue

src/plugins/chat/prompt_builder.py

@@ -141,21 +141,21 @@ class PromptBuilder:
         logger.debug(f"知识检索耗时: {(end_time - start_time):.3f}秒")
 
         prompt = f"""
-今天是{current_date}，现在是{current_time}，你今天的日程是：\
+今天是{current_date}，现在是{current_time}，你今天的日程是：
-`<schedule>`\n
+`<schedule>`
-{bot_schedule.today_schedule}\n
+{bot_schedule.today_schedule}
-`</schedule>`\n
+`</schedule>`
-{prompt_info}\n
+{prompt_info}
-{memory_prompt}\n
+{memory_prompt}
-{chat_target}\n
+{chat_target}
-{chat_talking_prompt}\n
+{chat_talking_prompt}
-现在"{sender_name}"说的:\n
+现在"{sender_name}"说的:
-`<UserMessage>`\n
+`<UserMessage>`
-{message_txt}\n
+{message_txt}
-`</UserMessage>`\n
+`</UserMessage>`
 引起了你的注意,{relation_prompt_all}{mood_prompt}\n
 `<MainRule>`
-你的网名叫{global_config.BOT_NICKNAME}，{prompt_personality}。
+你的网名叫{global_config.BOT_NICKNAME}，有人也叫你{"/".join(global_config.BOT_ALIAS_NAMES)}，{prompt_personality},{prompt_personality}。
 正在{bot_schedule_now_activity}的你同时也在一边{chat_target_2},现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，
 尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要刻意突出自身学科背景，不要回复的太有条理，可以有个性。
 {prompt_ger}

src/plugins/chat/topic_identifier.py

@@ -33,7 +33,7 @@ class TopicIdentifier:
 消息内容：{text}"""
 
         # 使用 LLM_request 类进行请求
-        topic, _ = await self.llm_topic_judge.generate_response(prompt)
+        topic, _, _ = await self.llm_topic_judge.generate_response(prompt)
 
         if not topic:
             logger.error("LLM API 返回为空")

src/plugins/chat/utils.py

@@ -55,9 +55,9 @@ def is_mentioned_bot_in_message(message: MessageRecv) -> bool:
     return False
 
 
-async def get_embedding(text):
+async def get_embedding(text, request_type="embedding"):
     """获取文本的embedding向量"""
-    llm = LLM_request(model=global_config.embedding, request_type="embedding")
+    llm = LLM_request(model=global_config.embedding, request_type=request_type)
     # return llm.get_embedding_sync(text)
     return await llm.get_embedding(text)
 
@@ -76,18 +76,11 @@ def calculate_information_content(text):
 
 
 def get_closest_chat_from_db(length: int, timestamp: str):
-    """从数据库中获取最接近指定时间戳的聊天记录
+    # print(f"获取最接近指定时间戳的聊天记录，长度: {length}, 时间戳: {timestamp}")
-
+    # print(f"当前时间: {timestamp},转换后时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp))}")
-    Args:
-        length: 要获取的消息数量
-        timestamp: 时间戳
-
-    Returns:
-        list: 消息记录列表，每个记录包含时间和文本信息
-    """
     chat_records = []
     closest_record = db.messages.find_one({"time": {"$lte": timestamp}}, sort=[("time", -1)])
-
+    # print(f"最接近的记录: {closest_record}")
     if closest_record:
         closest_time = closest_record["time"]
         chat_id = closest_record["chat_id"]  # 获取chat_id
@@ -102,7 +95,9 @@ def get_closest_chat_from_db(length: int, timestamp: str):
             .sort("time", 1)
             .limit(length)
         )
-
+        # print(f"获取到的记录: {chat_records}")
+        length = len(chat_records)
+        # print(f"获取到的记录长度: {length}")
         # 转换记录格式
         formatted_records = []
         for record in chat_records:
@@ -319,7 +314,7 @@ def split_into_sentences_w_remove_punctuation(text: str) -> List[str]:
             sentence = sentence.replace("，", " ").replace(",", " ")
         sentences_done.append(sentence)
 
-    logger.info(f"处理后的句子: {sentences_done}")
+    logger.debug(f"处理后的句子: {sentences_done}")
     return sentences_done
 
 

src/plugins/chat/utils_image.py

@@ -112,7 +112,7 @@ class ImageManager:
             # 查询缓存的描述
             cached_description = self._get_description_from_db(image_hash, "emoji")
             if cached_description:
-                logger.info(f"缓存表情包描述: {cached_description}")
+                logger.debug(f"缓存表情包描述: {cached_description}")
                 return f"[表情包：{cached_description}]"
 
             # 调用AI获取描述
@@ -184,7 +184,7 @@ class ImageManager:
                 logger.warning(f"虽然生成了描述，但是找到缓存图片描述 {cached_description}")
                 return f"[图片：{cached_description}]"
 
-            logger.info(f"描述是{description}")
+            logger.debug(f"描述是{description}")
 
             if description is None:
                 logger.warning("AI未能生成图片描述")

src/plugins/memory_system/memory.py

@@ -18,6 +18,7 @@ from ..chat.utils import (
 )
 from ..models.utils_model import LLM_request
 from src.common.logger import get_module_logger, LogConfig, MEMORY_STYLE_CONFIG
+from src.plugins.memory_system.sample_distribution import MemoryBuildScheduler
 
 # 定义日志配置
 memory_config = LogConfig(
@@ -25,6 +26,11 @@ memory_config = LogConfig(
     console_format=MEMORY_STYLE_CONFIG["console_format"],
     file_format=MEMORY_STYLE_CONFIG["file_format"],
 )
+# print(f"memory_config: {memory_config}")
+# print(f"MEMORY_STYLE_CONFIG: {MEMORY_STYLE_CONFIG}")
+# print(f"MEMORY_STYLE_CONFIG['console_format']: {MEMORY_STYLE_CONFIG['console_format']}")
+# print(f"MEMORY_STYLE_CONFIG['file_format']: {MEMORY_STYLE_CONFIG['file_format']}")
+
 
 logger = get_module_logger("memory_system", config=memory_config)
 
@@ -168,9 +174,9 @@ class Memory_graph:
 class Hippocampus:
     def __init__(self, memory_graph: Memory_graph):
         self.memory_graph = memory_graph
-        self.llm_topic_judge = LLM_request(model=global_config.llm_topic_judge, temperature=0.5, request_type="topic")
+        self.llm_topic_judge = LLM_request(model=global_config.llm_topic_judge, temperature=0.5, request_type="memory")
         self.llm_summary_by_topic = LLM_request(
-            model=global_config.llm_summary_by_topic, temperature=0.5, request_type="topic"
+            model=global_config.llm_summary_by_topic, temperature=0.5, request_type="memory"
         )
 
     def get_all_node_names(self) -> list:
@@ -195,25 +201,17 @@ class Hippocampus:
         return hash(f"{nodes[0]}:{nodes[1]}")
 
     def random_get_msg_snippet(self, target_timestamp: float, chat_size: int, max_memorized_time_per_msg: int) -> list:
-        """随机抽取一段时间内的消息片段
-        Args:
-            - target_timestamp: 目标时间戳
-            - chat_size: 抽取的消息数量
-            - max_memorized_time_per_msg: 每条消息的最大记忆次数
-
-        Returns:
-            - list: 抽取出的消息记录列表
-
-        """
         try_count = 0
-        # 最多尝试三次抽取
+        # 最多尝试2次抽取
         while try_count < 3:
             messages = get_closest_chat_from_db(length=chat_size, timestamp=target_timestamp)
             if messages:
+                # print(f"抽取到的消息: {messages}")
                 # 检查messages是否均没有达到记忆次数限制
                 for message in messages:
                     if message["memorized_times"] >= max_memorized_time_per_msg:
                         messages = None
+                        # print(f"抽取到的消息提取次数达到限制，跳过")
                         break
                 if messages:
                     # 成功抽取短期消息样本
@@ -224,63 +222,48 @@ class Hippocampus:
                         )
                     return messages
             try_count += 1
-        # 三次尝试均失败
         return None
 
-    def get_memory_sample(self, chat_size=20, time_frequency=None):
+    def get_memory_sample(self):
-        """获取记忆样本
-
-        Returns:
-            list: 消息记录列表，每个元素是一个消息记录字典列表
-        """
         # 硬编码：每条消息最大记忆次数
         # 如有需求可写入global_config
-        if time_frequency is None:
-            time_frequency = {"near": 2, "mid": 4, "far": 3}
         max_memorized_time_per_msg = 3
 
-        current_timestamp = datetime.datetime.now().timestamp()
+        # 创建双峰分布的记忆调度器
+        scheduler = MemoryBuildScheduler(
+            n_hours1=global_config.memory_build_distribution[0],           # 第一个分布均值（4小时前）
+            std_hours1=global_config.memory_build_distribution[1],         # 第一个分布标准差
+            weight1=global_config.memory_build_distribution[2],          # 第一个分布权重 60%
+            n_hours2=global_config.memory_build_distribution[3],          # 第二个分布均值（24小时前）
+            std_hours2=global_config.memory_build_distribution[4],         # 第二个分布标准差
+            weight2=global_config.memory_build_distribution[5],          # 第二个分布权重 40%
+            total_samples=global_config.build_memory_sample_num      # 总共生成10个时间点
+        )
+
+        # 生成时间戳数组
+        timestamps = scheduler.get_timestamp_array()
+        # logger.debug(f"生成的时间戳数组: {timestamps}")
+        # print(f"生成的时间戳数组: {timestamps}")
+        # print(f"时间戳的实际时间: {[time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)) for ts in timestamps]}")
+        logger.info(f"回忆往事: {[time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)) for ts in timestamps]}")
         chat_samples = []
-
+        for timestamp in timestamps:
-        # 短期：1h   中期：4h   长期：24h
+            messages = self.random_get_msg_snippet(
-        logger.debug("正在抽取短期消息样本")
+                timestamp, 
-        for i in range(time_frequency.get("near")):
+                global_config.build_memory_sample_length, 
-            random_time = current_timestamp - random.randint(1, 3600)
+                max_memorized_time_per_msg
-            messages = self.random_get_msg_snippet(random_time, chat_size, max_memorized_time_per_msg)
+            )
             if messages:
-                logger.debug(f"成功抽取短期消息样本{len(messages)}条")
+                time_diff = (datetime.datetime.now().timestamp() - timestamp) / 3600
+                logger.debug(f"成功抽取 {time_diff:.1f} 小时前的消息样本，共{len(messages)}条")
+                # print(f"成功抽取 {time_diff:.1f} 小时前的消息样本，共{len(messages)}条")
                 chat_samples.append(messages)
             else:
-                logger.warning(f"第{i}次短期消息样本抽取失败")
+                logger.debug(f"时间戳 {timestamp} 的消息样本抽取失败")
-
-        logger.debug("正在抽取中期消息样本")
-        for i in range(time_frequency.get("mid")):
-            random_time = current_timestamp - random.randint(3600, 3600 * 4)
-            messages = self.random_get_msg_snippet(random_time, chat_size, max_memorized_time_per_msg)
-            if messages:
-                logger.debug(f"成功抽取中期消息样本{len(messages)}条")
-                chat_samples.append(messages)
-            else:
-                logger.warning(f"第{i}次中期消息样本抽取失败")
-
-        logger.debug("正在抽取长期消息样本")
-        for i in range(time_frequency.get("far")):
-            random_time = current_timestamp - random.randint(3600 * 4, 3600 * 24)
-            messages = self.random_get_msg_snippet(random_time, chat_size, max_memorized_time_per_msg)
-            if messages:
-                logger.debug(f"成功抽取长期消息样本{len(messages)}条")
-                chat_samples.append(messages)
-            else:
-                logger.warning(f"第{i}次长期消息样本抽取失败")
 
         return chat_samples
 
     async def memory_compress(self, messages: list, compress_rate=0.1):
-        """压缩消息记录为记忆
-
-        Returns:
-            tuple: (压缩记忆集合, 相似主题字典)
-        """
         if not messages:
             return set(), {}
 
@@ -313,15 +296,23 @@ class Hippocampus:
         topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(input_text, topic_num))
 
         # 过滤topics
+        # 从配置文件获取需要过滤的关键词列表
         filter_keywords = global_config.memory_ban_words
+        
+        # 将topics_response[0]中的中文逗号、顿号、空格都替换成英文逗号
+        # 然后按逗号分割成列表,并去除每个topic前后的空白字符
         topics = [
             topic.strip()
             for topic in topics_response[0].replace("，", ",").replace("、", ",").replace(" ", ",").split(",")
             if topic.strip()
         ]
+        
+        # 过滤掉包含禁用关键词的topic
+        # any()检查topic中是否包含任何一个filter_keywords中的关键词
+        # 只保留不包含禁用关键词的topic
         filtered_topics = [topic for topic in topics if not any(keyword in topic for keyword in filter_keywords)]
 
-        logger.info(f"过滤后话题: {filtered_topics}")
+        logger.debug(f"过滤后话题: {filtered_topics}")
 
         # 创建所有话题的请求任务
         tasks = []
@@ -331,31 +322,42 @@ class Hippocampus:
             tasks.append((topic.strip(), task))
 
         # 等待所有任务完成
-        compressed_memory = set()
+        # 初始化压缩后的记忆集合和相似主题字典
+        compressed_memory = set()  # 存储压缩后的(主题,内容)元组
         similar_topics_dict = {}  # 存储每个话题的相似主题列表
+        
+        # 遍历每个主题及其对应的LLM任务
         for topic, task in tasks:
             response = await task
             if response:
+                # 将主题和LLM生成的内容添加到压缩记忆中
                 compressed_memory.add((topic, response[0]))
-                # 为每个话题查找相似的已存在主题
+                
+                # 为当前主题寻找相似的已存在主题
                 existing_topics = list(self.memory_graph.G.nodes())
                 similar_topics = []
 
+                # 计算当前主题与每个已存在主题的相似度
                 for existing_topic in existing_topics:
+                    # 使用jieba分词,将主题转换为词集合
                     topic_words = set(jieba.cut(topic))
                     existing_words = set(jieba.cut(existing_topic))
 
-                    all_words = topic_words | existing_words
+                    # 构建词向量用于计算余弦相似度
-                    v1 = [1 if word in topic_words else 0 for word in all_words]
+                    all_words = topic_words | existing_words  # 所有不重复的词
-                    v2 = [1 if word in existing_words else 0 for word in all_words]
+                    v1 = [1 if word in topic_words else 0 for word in all_words]  # 当前主题的词向量
+                    v2 = [1 if word in existing_words else 0 for word in all_words]  # 已存在主题的词向量
 
+                    # 计算余弦相似度
                     similarity = cosine_similarity(v1, v2)
 
-                    if similarity >= 0.6:
+                    # 如果相似度超过阈值,添加到相似主题列表
+                    if similarity >= 0.7:
                         similar_topics.append((existing_topic, similarity))
 
+                # 按相似度降序排序,只保留前3个最相似的主题
                 similar_topics.sort(key=lambda x: x[1], reverse=True)
-                similar_topics = similar_topics[:5]
+                similar_topics = similar_topics[:3]
                 similar_topics_dict[topic] = similar_topics
 
         return compressed_memory, similar_topics_dict
@@ -372,10 +374,13 @@ class Hippocampus:
         )
         return topic_num
 
-    async def operation_build_memory(self, chat_size=20):
+    async def operation_build_memory(self):
-        time_frequency = {"near": 1, "mid": 4, "far": 4}
+        logger.debug("------------------------------------开始构建记忆--------------------------------------")
-        memory_samples = self.get_memory_sample(chat_size, time_frequency)
+        start_time = time.time()
-
+        memory_samples = self.get_memory_sample()
+        all_added_nodes = []
+        all_connected_nodes = []
+        all_added_edges = []
         for i, messages in enumerate(memory_samples, 1):
             all_topics = []
             # 加载进度可视化
@@ -387,12 +392,14 @@ class Hippocampus:
 
             compress_rate = global_config.memory_compress_rate
             compressed_memory, similar_topics_dict = await self.memory_compress(messages, compress_rate)
-            logger.info(f"压缩后记忆数量: {len(compressed_memory)}，似曾相识的话题: {len(similar_topics_dict)}")
+            logger.debug(f"压缩后记忆数量: {compressed_memory}，似曾相识的话题: {similar_topics_dict}")
 
             current_time = datetime.datetime.now().timestamp()
-
+            logger.debug(f"添加节点: {', '.join(topic for topic, _ in compressed_memory)}")
+            all_added_nodes.extend(topic for topic, _ in compressed_memory)
+            # all_connected_nodes.extend(topic for topic, _ in similar_topics_dict)
+            
             for topic, memory in compressed_memory:
-                logger.info(f"添加节点: {topic}")
                 self.memory_graph.add_dot(topic, memory)
                 all_topics.append(topic)
 
@@ -402,7 +409,13 @@ class Hippocampus:
                     for similar_topic, similarity in similar_topics:
                         if topic != similar_topic:
                             strength = int(similarity * 10)
-                            logger.info(f"连接相似节点: {topic} 和 {similar_topic} (强度: {strength})")
+                            
+                            logger.debug(f"连接相似节点: {topic} 和 {similar_topic} (强度: {strength})")
+                            all_added_edges.append(f"{topic}-{similar_topic}")
+                            
+                            all_connected_nodes.append(topic)
+                            all_connected_nodes.append(similar_topic)
+                            
                             self.memory_graph.G.add_edge(
                                 topic,
                                 similar_topic,
@@ -414,10 +427,21 @@ class Hippocampus:
             # 连接同批次的相关话题
             for i in range(len(all_topics)):
                 for j in range(i + 1, len(all_topics)):
-                    logger.info(f"连接同批次节点: {all_topics[i]} 和 {all_topics[j]}")
+                    logger.debug(f"连接同批次节点: {all_topics[i]} 和 {all_topics[j]}")
+                    all_added_edges.append(f"{all_topics[i]}-{all_topics[j]}")
                     self.memory_graph.connect_dot(all_topics[i], all_topics[j])
 
+        logger.success(f"更新记忆: {', '.join(all_added_nodes)}")
+        logger.debug(f"强化连接: {', '.join(all_added_edges)}")
+        logger.info(f"强化连接节点: {', '.join(all_connected_nodes)}")
+        # logger.success(f"强化连接: {', '.join(all_added_edges)}")
         self.sync_memory_to_db()
+        
+        end_time = time.time()
+        logger.success(
+            f"--------------------------记忆构建完成：耗时: {end_time - start_time:.2f} "
+            "秒--------------------------"
+        )
 
     def sync_memory_to_db(self):
         """检查并同步内存中的图结构与数据库"""
@@ -844,10 +868,9 @@ class Hippocampus:
 
     async def memory_activate_value(self, text: str, max_topics: int = 5, similarity_threshold: float = 0.3) -> int:
         """计算输入文本对记忆的激活程度"""
-        logger.info(f"识别主题: {await self._identify_topics(text)}")
-
         # 识别主题
         identified_topics = await self._identify_topics(text)
+        
         if not identified_topics:
             return 0
 
@@ -908,7 +931,8 @@ class Hippocampus:
 
         # 计算最终激活值
         activation = int((topic_match + average_similarities) / 2 * 100)
-        logger.info(f"匹配率: {topic_match:.3f}, 平均相似度: {average_similarities:.3f}, 激活值: {activation}")
+        
+        logger.info(f"识别主题: {identified_topics}, 匹配率: {topic_match:.3f}, 激活值: {activation}")
 
         return activation
 

src/plugins/memory_system/memory_manual_build.py

@@ -7,7 +7,6 @@ import sys
 import time
 from collections import Counter
 from pathlib import Path
-
 import matplotlib.pyplot as plt
 import networkx as nx
 from dotenv import load_dotenv
@@ -16,7 +15,6 @@ sys.path.insert(0, sys.path[0]+"/../")
 sys.path.insert(0, sys.path[0]+"/../")
 sys.path.insert(0, sys.path[0]+"/../")
 sys.path.insert(0, sys.path[0]+"/../")
-print(sys.path)
 from src.common.logger import get_module_logger
 import jieba
 
@@ -25,6 +23,7 @@ import jieba
 root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
 sys.path.append(root_path)
 
+from src.common.logger import get_module_logger # noqa: E402
 from src.common.database import db  # noqa E402
 from src.plugins.memory_system.offline_llm import LLMModel  # noqa E402
 

src/plugins/memory_system/sample_distribution.py

@@ -0,0 +1,170 @@
+import numpy as np
+from scipy import stats
+from datetime import datetime, timedelta
+
+class DistributionVisualizer:
+    def __init__(self, mean=0, std=1, skewness=0, sample_size=10):
+        """
+        初始化分布可视化器
+        
+        参数:
+            mean (float): 期望均值
+            std (float): 标准差
+            skewness (float): 偏度
+            sample_size (int): 样本大小
+        """
+        self.mean = mean
+        self.std = std
+        self.skewness = skewness
+        self.sample_size = sample_size
+        self.samples = None
+        
+    def generate_samples(self):
+        """生成具有指定参数的样本"""
+        if self.skewness == 0:
+            # 对于无偏度的情况，直接使用正态分布
+            self.samples = np.random.normal(loc=self.mean, scale=self.std, size=self.sample_size)
+        else:
+            # 使用 scipy.stats 生成具有偏度的分布
+            self.samples = stats.skewnorm.rvs(a=self.skewness, 
+                                            loc=self.mean, 
+                                            scale=self.std, 
+                                            size=self.sample_size)
+    
+    def get_weighted_samples(self):
+        """获取加权后的样本数列"""
+        if self.samples is None:
+            self.generate_samples()
+        # 将样本值乘以样本大小
+        return self.samples * self.sample_size
+        
+    def get_statistics(self):
+        """获取分布的统计信息"""
+        if self.samples is None:
+            self.generate_samples()
+            
+        return {
+            "均值": np.mean(self.samples),
+            "标准差": np.std(self.samples),
+            "实际偏度": stats.skew(self.samples)
+        }
+
+class MemoryBuildScheduler:
+    def __init__(self, 
+                 n_hours1, std_hours1, weight1,
+                 n_hours2, std_hours2, weight2,
+                 total_samples=50):
+        """
+        初始化记忆构建调度器
+        
+        参数:
+            n_hours1 (float): 第一个分布的均值（距离现在的小时数）
+            std_hours1 (float): 第一个分布的标准差（小时）
+            weight1 (float): 第一个分布的权重
+            n_hours2 (float): 第二个分布的均值（距离现在的小时数）
+            std_hours2 (float): 第二个分布的标准差（小时）
+            weight2 (float): 第二个分布的权重
+            total_samples (int): 要生成的总时间点数量
+        """
+        # 归一化权重
+        total_weight = weight1 + weight2
+        self.weight1 = weight1 / total_weight
+        self.weight2 = weight2 / total_weight
+        
+        self.n_hours1 = n_hours1
+        self.std_hours1 = std_hours1
+        self.n_hours2 = n_hours2
+        self.std_hours2 = std_hours2
+        self.total_samples = total_samples
+        self.base_time = datetime.now()
+        
+    def generate_time_samples(self):
+        """生成混合分布的时间采样点"""
+        # 根据权重计算每个分布的样本数
+        samples1 = int(self.total_samples * self.weight1)
+        samples2 = self.total_samples - samples1
+        
+        # 生成两个正态分布的小时偏移
+        hours_offset1 = np.random.normal(
+            loc=self.n_hours1,
+            scale=self.std_hours1,
+            size=samples1
+        )
+        
+        hours_offset2 = np.random.normal(
+            loc=self.n_hours2,
+            scale=self.std_hours2,
+            size=samples2
+        )
+        
+        # 合并两个分布的偏移
+        hours_offset = np.concatenate([hours_offset1, hours_offset2])
+        
+        # 将偏移转换为实际时间戳（使用绝对值确保时间点在过去）
+        timestamps = [self.base_time - timedelta(hours=abs(offset)) for offset in hours_offset]
+        
+        # 按时间排序（从最早到最近）
+        return sorted(timestamps)
+
+    def get_timestamp_array(self):
+        """返回时间戳数组"""
+        timestamps = self.generate_time_samples()
+        return [int(t.timestamp()) for t in timestamps]
+
+def print_time_samples(timestamps, show_distribution=True):
+    """打印时间样本和分布信息"""
+    print(f"\n生成的{len(timestamps)}个时间点分布：")
+    print("序号".ljust(5), "时间戳".ljust(25), "距现在（小时）")
+    print("-" * 50)
+    
+    now = datetime.now()
+    time_diffs = []
+    
+    for i, timestamp in enumerate(timestamps, 1):
+        hours_diff = (now - timestamp).total_seconds() / 3600
+        time_diffs.append(hours_diff)
+        print(f"{str(i).ljust(5)} {timestamp.strftime('%Y-%m-%d %H:%M:%S').ljust(25)} {hours_diff:.2f}")
+    
+    # 打印统计信息
+    print("\n统计信息：")
+    print(f"平均时间偏移：{np.mean(time_diffs):.2f}小时")
+    print(f"标准差：{np.std(time_diffs):.2f}小时")
+    print(f"最早时间：{min(timestamps).strftime('%Y-%m-%d %H:%M:%S')} ({max(time_diffs):.2f}小时前)")
+    print(f"最近时间：{max(timestamps).strftime('%Y-%m-%d %H:%M:%S')} ({min(time_diffs):.2f}小时前)")
+    
+    if show_distribution:
+        # 计算时间分布的直方图
+        hist, bins = np.histogram(time_diffs, bins=40)
+        print("\n时间分布（每个*代表一个时间点）：")
+        for i in range(len(hist)):
+            if hist[i] > 0:
+                print(f"{bins[i]:6.1f}-{bins[i+1]:6.1f}小时: {'*' * int(hist[i])}")
+
+# 使用示例
+if __name__ == "__main__":
+    # 创建一个双峰分布的记忆调度器
+    scheduler = MemoryBuildScheduler(
+        n_hours1=12,          # 第一个分布均值（12小时前）
+        std_hours1=8,         # 第一个分布标准差
+        weight1=0.7,          # 第一个分布权重 70%
+        n_hours2=36,          # 第二个分布均值（36小时前）
+        std_hours2=24,        # 第二个分布标准差
+        weight2=0.3,          # 第二个分布权重 30%
+        total_samples=50      # 总共生成50个时间点
+    )
+    
+    # 生成时间分布
+    timestamps = scheduler.generate_time_samples()
+    
+    # 打印结果，包含分布可视化
+    print_time_samples(timestamps, show_distribution=True)
+    
+    # 打印时间戳数组
+    timestamp_array = scheduler.get_timestamp_array()
+    print("\n时间戳数组（Unix时间戳）：")
+    print("[", end="")
+    for i, ts in enumerate(timestamp_array):
+        if i > 0:
+            print(", ", end="")
+        print(ts, end="")
+    print("]")

src/plugins/models/utils_model.py

@@ -524,11 +524,11 @@ class LLM_request:
             return {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
             # 防止小朋友们截图自己的key
 
-    async def generate_response(self, prompt: str) -> Tuple[str, str]:
+    async def generate_response(self, prompt: str) -> Tuple[str, str, str]:
         """根据输入的提示生成模型的异步响应"""
 
         content, reasoning_content = await self._execute_request(endpoint="/chat/completions", prompt=prompt)
-        return content, reasoning_content
+        return content, reasoning_content, self.model_name
 
     async def generate_response_for_image(self, prompt: str, image_base64: str, image_format: str) -> Tuple[str, str]:
         """根据输入的提示和图片生成模型的异步响应"""
@@ -583,7 +583,8 @@ class LLM_request:
                         completion_tokens=completion_tokens,
                         total_tokens=total_tokens,
                         user_id="system",  # 可以根据需要修改 user_id
-                        request_type="embedding",  # 请求类型为 embedding
+                        # request_type="embedding",  # 请求类型为 embedding
+                        request_type=self.request_type,  # 请求类型为 text
                         endpoint="/embeddings",  # API 端点
                     )
                     return result["data"][0].get("embedding", None)

src/plugins/personality/big5_test.py

@@ -15,17 +15,14 @@ env_path = project_root / ".env.prod"
 root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
 sys.path.append(root_path)
 
-from src.plugins.personality.scene import get_scene_by_factor,get_all_scenes,PERSONALITY_SCENES
+from src.plugins.personality.questionnaire import PERSONALITY_QUESTIONS, FACTOR_DESCRIPTIONS  # noqa: E402
-from src.plugins.personality.questionnaire import PERSONALITY_QUESTIONS,FACTOR_DESCRIPTIONS
-from src.plugins.personality.offline_llm import LLMModel 
-
 
 
 class BigFiveTest:
     def __init__(self):
         self.questions = PERSONALITY_QUESTIONS
         self.factors = FACTOR_DESCRIPTIONS
-        
+
     def run_test(self):
         """运行测试并收集答案"""
         print("\n欢迎参加中国大五人格测试！")
@@ -37,17 +34,17 @@ class BigFiveTest:
         print("5 = 比较符合")
         print("6 = 完全符合")
         print("\n请认真阅读每个描述，选择最符合您实际情况的选项。\n")
-        
+
         # 创建题目序号到题目的映射
-        questions_map = {q['id']: q for q in self.questions}
+        questions_map = {q["id"]: q for q in self.questions}
-        
+
         # 获取所有题目ID并随机打乱顺序
         question_ids = list(questions_map.keys())
         random.shuffle(question_ids)
-        
+
         answers = {}
         total_questions = len(question_ids)
-        
+
         for i, question_id in enumerate(question_ids, 1):
             question = questions_map[question_id]
             while True:
@@ -61,52 +58,43 @@ class BigFiveTest:
                         print("请输入1-6之间的数字！")
                 except ValueError:
                     print("请输入有效的数字！")
-        
+
         return self.calculate_scores(answers)
-    
+
     def calculate_scores(self, answers):
         """计算各维度得分"""
         results = {}
-        factor_questions = {
+        factor_questions = {"外向性": [], "神经质": [], "严谨性": [], "开放性": [], "宜人性": []}
-            "外向性": [],
+
-            "神经质": [],
-            "严谨性": [],
-            "开放性": [],
-            "宜人性": []
-        }
-        
         # 将题目按因子分类
         for q in self.questions:
-            factor_questions[q['factor']].append(q)
+            factor_questions[q["factor"]].append(q)
-        
+
         # 计算每个维度的得分
         for factor, questions in factor_questions.items():
             total_score = 0
             for q in questions:
-                score = answers[q['id']]
+                score = answers[q["id"]]
                 # 处理反向计分题目
-                if q['reverse_scoring']:
+                if q["reverse_scoring"]:
                     score = 7 - score  # 6分量表反向计分为7减原始分
                 total_score += score
-            
+
             # 计算平均分
             avg_score = round(total_score / len(questions), 2)
-            results[factor] = {
+            results[factor] = {"得分": avg_score, "题目数": len(questions), "总分": total_score}
-                "得分": avg_score,
+
-                "题目数": len(questions),
-                "总分": total_score
-            }
-        
         return results
 
     def get_factor_description(self, factor):
         """获取因子的详细描述"""
         return self.factors[factor]
 
+
 def main():
     test = BigFiveTest()
     results = test.run_test()
-    
+
     print("\n测试结果：")
     print("=" * 50)
     for factor, data in results.items():
@@ -114,9 +102,10 @@ def main():
         print(f"平均分: {data['得分']} (总分: {data['总分']}, 题目数: {data['题目数']})")
         print("-" * 30)
         description = test.get_factor_description(factor)
-        print("维度说明:", description['description'][:100] + "...")
+        print("维度说明:", description["description"][:100] + "...")
-        print("\n特征词:", ", ".join(description['trait_words']))
+        print("\n特征词:", ", ".join(description["trait_words"]))
     print("=" * 50)
-    
+
+
 if __name__ == "__main__":
     main()

src/plugins/personality/combined_test.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict
 import json
 import os
 from pathlib import Path
@@ -14,16 +14,17 @@ env_path = project_root / ".env.prod"
 root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
 sys.path.append(root_path)
 
-from src.plugins.personality.big5_test import BigFiveTest
+from src.plugins.personality.big5_test import BigFiveTest  # noqa: E402
-from src.plugins.personality.renqingziji import PersonalityEvaluator_direct
+from src.plugins.personality.renqingziji import PersonalityEvaluator_direct  # noqa: E402
-from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS, PERSONALITY_QUESTIONS
+from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS, PERSONALITY_QUESTIONS  # noqa: E402
+
 
 class CombinedPersonalityTest:
     def __init__(self):
         self.big5_test = BigFiveTest()
         self.scenario_test = PersonalityEvaluator_direct()
         self.dimensions = ["开放性", "严谨性", "外向性", "宜人性", "神经质"]
-        
+
     def run_combined_test(self):
         """运行组合测试"""
         print("\n=== 人格特征综合评估系统 ===")
@@ -32,12 +33,12 @@ class CombinedPersonalityTest:
         print("2. 情景反应测评（15个场景）")
         print("\n两种测评完成后，将对比分析结果的异同。")
         input("\n准备好开始第一部分（问卷测评）了吗？按回车继续...")
-        
+
         # 运行问卷测试
         print("\n=== 第一部分：问卷测评 ===")
         print("本部分采用六级评分，请根据每个描述与您的符合程度进行打分：")
         print("1 = 完全不符合")
-        print("2 = 比较不符合") 
+        print("2 = 比较不符合")
         print("3 = 有点不符合")
         print("4 = 有点符合")
         print("5 = 比较符合")
@@ -47,42 +48,39 @@ class CombinedPersonalityTest:
         print("2. 根据您想要扮演的角色特征来回答")
         print("\n无论选择哪种方式，请保持一致并认真回答每个问题。")
         input("\n按回车开始答题...")
-        
+
         questionnaire_results = self.run_questionnaire()
-        
+
         # 转换问卷结果格式以便比较
-        questionnaire_scores = {
+        questionnaire_scores = {factor: data["得分"] for factor, data in questionnaire_results.items()}
-            factor: data["得分"] 
+
-            for factor, data in questionnaire_results.items()
-        }
-        
         # 运行情景测试
         print("\n=== 第二部分：情景反应测评 ===")
         print("接下来，您将面对一系列具体场景，请描述您在每个场景中可能的反应。")
         print("每个场景都会评估不同的人格维度，共15个场景。")
         print("您可以选择提供自己的真实反应，也可以选择扮演一个您创作的角色来回答。")
         input("\n准备好开始了吗？按回车继续...")
-        
+
         scenario_results = self.run_scenario_test()
-        
+
         # 比较和展示结果
         self.compare_and_display_results(questionnaire_scores, scenario_results)
-        
+
         # 保存结果
         self.save_results(questionnaire_scores, scenario_results)
 
     def run_questionnaire(self):
         """运行问卷测试部分"""
         # 创建题目序号到题目的映射
-        questions_map = {q['id']: q for q in PERSONALITY_QUESTIONS}
+        questions_map = {q["id"]: q for q in PERSONALITY_QUESTIONS}
-        
+
         # 获取所有题目ID并随机打乱顺序
         question_ids = list(questions_map.keys())
         random.shuffle(question_ids)
-        
+
         answers = {}
         total_questions = len(question_ids)
-        
+
         for i, question_id in enumerate(question_ids, 1):
             question = questions_map[question_id]
             while True:
@@ -97,48 +95,38 @@ class CombinedPersonalityTest:
                         print("请输入1-6之间的数字！")
                 except ValueError:
                     print("请输入有效的数字！")
-                    
+
             # 每10题显示一次进度
             if i % 10 == 0:
-                print(f"\n已完成 {i}/{total_questions} 题 ({int(i/total_questions*100)}%)")
+                print(f"\n已完成 {i}/{total_questions} 题 ({int(i / total_questions * 100)}%)")
-        
+
         return self.calculate_questionnaire_scores(answers)
-        
+
     def calculate_questionnaire_scores(self, answers):
         """计算问卷测试的维度得分"""
         results = {}
-        factor_questions = {
+        factor_questions = {"外向性": [], "神经质": [], "严谨性": [], "开放性": [], "宜人性": []}
-            "外向性": [],
+
-            "神经质": [],
-            "严谨性": [],
-            "开放性": [],
-            "宜人性": []
-        }
-        
         # 将题目按因子分类
         for q in PERSONALITY_QUESTIONS:
-            factor_questions[q['factor']].append(q)
+            factor_questions[q["factor"]].append(q)
-        
+
         # 计算每个维度的得分
         for factor, questions in factor_questions.items():
             total_score = 0
             for q in questions:
-                score = answers[q['id']]
+                score = answers[q["id"]]
                 # 处理反向计分题目
-                if q['reverse_scoring']:
+                if q["reverse_scoring"]:
                     score = 7 - score  # 6分量表反向计分为7减原始分
                 total_score += score
-            
+
             # 计算平均分
             avg_score = round(total_score / len(questions), 2)
-            results[factor] = {
+            results[factor] = {"得分": avg_score, "题目数": len(questions), "总分": total_score}
-                "得分": avg_score,
+
-                "题目数": len(questions),
-                "总分": total_score
-            }
-        
         return results
-        
+
     def run_scenario_test(self):
         """运行情景测试部分"""
         final_scores = {"开放性": 0, "严谨性": 0, "外向性": 0, "宜人性": 0, "神经质": 0}
@@ -160,11 +148,7 @@ class CombinedPersonalityTest:
                 continue
 
             print("\n正在评估您的描述...")
-            scores = self.scenario_test.evaluate_response(
+            scores = self.scenario_test.evaluate_response(scenario_data["场景"], response, scenario_data["评估维度"])
-                scenario_data["场景"], 
-                response, 
-                scenario_data["评估维度"]
-            )
 
             # 更新分数
             for dimension, score in scores.items():
@@ -178,7 +162,7 @@ class CombinedPersonalityTest:
 
             # 每5个场景显示一次总进度
             if i % 5 == 0:
-                print(f"\n已完成 {i}/{len(scenarios)} 个场景 ({int(i/len(scenarios)*100)}%)")
+                print(f"\n已完成 {i}/{len(scenarios)} 个场景 ({int(i / len(scenarios) * 100)}%)")
 
             if i < len(scenarios):
                 input("\n按回车继续下一个场景...")
@@ -186,11 +170,8 @@ class CombinedPersonalityTest:
         # 计算平均分
         for dimension in final_scores:
             if dimension_counts[dimension] > 0:
-                final_scores[dimension] = round(
+                final_scores[dimension] = round(final_scores[dimension] / dimension_counts[dimension], 2)
-                    final_scores[dimension] / dimension_counts[dimension], 
+
-                    2
-                )
-                
         return final_scores
 
     def compare_and_display_results(self, questionnaire_scores: Dict, scenario_scores: Dict):
@@ -199,39 +180,43 @@ class CombinedPersonalityTest:
         print("\n" + "=" * 60)
         print(f"{'维度':<8} {'问卷得分':>10} {'情景得分':>10} {'差异':>10} {'差异程度':>10}")
         print("-" * 60)
-        
+
         # 收集每个维度的得分用于统计分析
         questionnaire_values = []
         scenario_values = []
         diffs = []
-        
+
         for dimension in self.dimensions:
             q_score = questionnaire_scores[dimension]
             s_score = scenario_scores[dimension]
             diff = round(abs(q_score - s_score), 2)
-            
+
             questionnaire_values.append(q_score)
             scenario_values.append(s_score)
             diffs.append(diff)
-            
+
             # 计算差异程度
             diff_level = "低" if diff < 0.5 else "中" if diff < 1.0 else "高"
             print(f"{dimension:<8} {q_score:>10.2f} {s_score:>10.2f} {diff:>10.2f} {diff_level:>10}")
-        
+
         print("=" * 60)
-        
+
         # 计算整体统计指标
         mean_diff = sum(diffs) / len(diffs)
         std_diff = (sum((x - mean_diff) ** 2 for x in diffs) / (len(diffs) - 1)) ** 0.5
-        
+
         # 计算效应量 (Cohen's d)
-        pooled_std = ((sum((x - sum(questionnaire_values)/len(questionnaire_values))**2 for x in questionnaire_values) +
+        pooled_std = (
-                      sum((x - sum(scenario_values)/len(scenario_values))**2 for x in scenario_values)) /
+            (
-                     (2 * len(self.dimensions) - 2)) ** 0.5
+                sum((x - sum(questionnaire_values) / len(questionnaire_values)) ** 2 for x in questionnaire_values)
-        
+                + sum((x - sum(scenario_values) / len(scenario_values)) ** 2 for x in scenario_values)
+            )
+            / (2 * len(self.dimensions) - 2)
+        ) ** 0.5
+
         if pooled_std != 0:
             cohens_d = abs(mean_diff / pooled_std)
-            
+
             # 解释效应量
             if cohens_d < 0.2:
                 effect_size = "微小"
@@ -241,41 +226,43 @@ class CombinedPersonalityTest:
                 effect_size = "中等"
             else:
                 effect_size = "大"
-        
+
         # 对所有维度进行整体t检验
         t_stat, p_value = stats.ttest_rel(questionnaire_values, scenario_values)
-        print(f"\n整体统计分析:")
+        print("\n整体统计分析:")
         print(f"平均差异: {mean_diff:.3f}")
         print(f"差异标准差: {std_diff:.3f}")
         print(f"效应量(Cohen's d): {cohens_d:.3f}")
         print(f"效应量大小: {effect_size}")
         print(f"t统计量: {t_stat:.3f}")
         print(f"p值: {p_value:.3f}")
-        
+
         if p_value < 0.05:
             print("结论: 两种测评方法的结果存在显著差异 (p < 0.05)")
         else:
             print("结论: 两种测评方法的结果无显著差异 (p >= 0.05)")
-            
+
         print("\n维度说明：")
         for dimension in self.dimensions:
             print(f"\n{dimension}:")
             desc = FACTOR_DESCRIPTIONS[dimension]
             print(f"定义：{desc['description']}")
             print(f"特征词：{', '.join(desc['trait_words'])}")
-            
+
         # 分析显著差异
         significant_diffs = []
         for dimension in self.dimensions:
             diff = abs(questionnaire_scores[dimension] - scenario_scores[dimension])
             if diff >= 1.0:  # 差异大于等于1分视为显著
-                significant_diffs.append({
+                significant_diffs.append(
-                    "dimension": dimension,
+                    {
-                    "diff": diff,
+                        "dimension": dimension,
-                    "questionnaire": questionnaire_scores[dimension],
+                        "diff": diff,
-                    "scenario": scenario_scores[dimension]
+                        "questionnaire": questionnaire_scores[dimension],
-                })
+                        "scenario": scenario_scores[dimension],
-        
+                    }
+                )
+
         if significant_diffs:
             print("\n\n显著差异分析：")
             print("-" * 40)
@@ -284,9 +271,9 @@ class CombinedPersonalityTest:
                 print(f"问卷得分：{diff['questionnaire']:.2f}")
                 print(f"情景得分：{diff['scenario']:.2f}")
                 print(f"差异值：{diff['diff']:.2f}")
-                
+
                 # 分析可能的原因
-                if diff['questionnaire'] > diff['scenario']:
+                if diff["questionnaire"] > diff["scenario"]:
                     print("可能原因：在问卷中的自我评价较高，但在具体情景中的表现较为保守。")
                 else:
                     print("可能原因：在具体情景中表现出更多该维度特征，而在问卷自评时较为保守。")
@@ -297,38 +284,37 @@ class CombinedPersonalityTest:
             "测试时间": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
             "问卷测评结果": questionnaire_scores,
             "情景测评结果": scenario_scores,
-            "维度说明": FACTOR_DESCRIPTIONS
+            "维度说明": FACTOR_DESCRIPTIONS,
         }
-        
+
         # 确保目录存在
         os.makedirs("results", exist_ok=True)
-        
+
         # 生成带时间戳的文件名
         filename = f"results/personality_combined_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-        
+
         # 保存到文件
         with open(filename, "w", encoding="utf-8") as f:
             json.dump(results, f, ensure_ascii=False, indent=2)
-            
+
         print(f"\n完整的测评结果已保存到：{filename}")
 
+
 def load_existing_results():
     """检查并加载已有的测试结果"""
     results_dir = "results"
     if not os.path.exists(results_dir):
         return None
-        
+
     # 获取所有personality_combined开头的文件
-    result_files = [f for f in os.listdir(results_dir) 
+    result_files = [f for f in os.listdir(results_dir) if f.startswith("personality_combined_") and f.endswith(".json")]
-                   if f.startswith("personality_combined_") and f.endswith(".json")]
+
-    
     if not result_files:
         return None
-        
+
     # 按文件修改时间排序，获取最新的结果文件
-    latest_file = max(result_files, 
+    latest_file = max(result_files, key=lambda f: os.path.getmtime(os.path.join(results_dir, f)))
-                     key=lambda f: os.path.getmtime(os.path.join(results_dir, f)))
+
-    
     print(f"\n发现已有的测试结果：{latest_file}")
     try:
         with open(os.path.join(results_dir, latest_file), "r", encoding="utf-8") as f:
@@ -338,24 +324,26 @@ def load_existing_results():
         print(f"读取结果文件时出错：{str(e)}")
         return None
 
+
 def main():
     test = CombinedPersonalityTest()
-    
+
     # 检查是否存在已有结果
     existing_results = load_existing_results()
-    
+
     if existing_results:
         print("\n=== 使用已有测试结果进行分析 ===")
         print(f"测试时间：{existing_results['测试时间']}")
-        
+
         questionnaire_scores = existing_results["问卷测评结果"]
         scenario_scores = existing_results["情景测评结果"]
-        
+
         # 直接进行结果对比分析
         test.compare_and_display_results(questionnaire_scores, scenario_scores)
     else:
         print("\n未找到已有的测试结果，开始新的测试...")
         test.run_combined_test()
 
+
 if __name__ == "__main__":
-    main() 
+    main()

src/plugins/personality/questionnaire.py

@@ -1,5 +1,9 @@
-# 人格测试问卷题目 王孟成, 戴晓阳, & 姚树桥. (2011). 中国大五人格问卷的初步编制Ⅲ:简式版的制定及信效度检验. 中国临床心理学杂志, 19(04), Article 04.
+# 人格测试问卷题目
-# 王孟成, 戴晓阳, & 姚树桥. (2010). 中国大五人格问卷的初步编制Ⅰ:理论框架与信度分析. 中国临床心理学杂志, 18(05), Article 05.
+# 王孟成, 戴晓阳, & 姚树桥. (2011).
+# 中国大五人格问卷的初步编制Ⅲ:简式版的制定及信效度检验. 中国临床心理学杂志, 19(04), Article 04.
+
+# 王孟成, 戴晓阳, & 姚树桥. (2010).
+# 中国大五人格问卷的初步编制Ⅰ:理论框架与信度分析. 中国临床心理学杂志, 18(05), Article 05.
 
 PERSONALITY_QUESTIONS = [
     # 神经质维度 (F1)
@@ -11,7 +15,6 @@ PERSONALITY_QUESTIONS = [
     {"id": 6, "content": "在面对压力时，我有种快要崩溃的感觉", "factor": "神经质", "reverse_scoring": False},
     {"id": 7, "content": "我常担忧一些无关紧要的事情", "factor": "神经质", "reverse_scoring": False},
     {"id": 8, "content": "我常常感到内心不踏实", "factor": "神经质", "reverse_scoring": False},
-    
     # 严谨性维度 (F2)
     {"id": 9, "content": "在工作上，我常只求能应付过去便可", "factor": "严谨性", "reverse_scoring": True},
     {"id": 10, "content": "一旦确定了目标，我会坚持努力地实现它", "factor": "严谨性", "reverse_scoring": False},
@@ -21,9 +24,13 @@ PERSONALITY_QUESTIONS = [
     {"id": 14, "content": "我喜欢一开头就把事情计划好", "factor": "严谨性", "reverse_scoring": False},
     {"id": 15, "content": "我工作或学习很勤奋", "factor": "严谨性", "reverse_scoring": False},
     {"id": 16, "content": "我是个倾尽全力做事的人", "factor": "严谨性", "reverse_scoring": False},
-    
     # 宜人性维度 (F3)
-    {"id": 17, "content": "尽管人类社会存在着一些阴暗的东西（如战争、罪恶、欺诈），我仍然相信人性总的来说是善良的", "factor": "宜人性", "reverse_scoring": False},
+    {
+        "id": 17,
+        "content": "尽管人类社会存在着一些阴暗的东西（如战争、罪恶、欺诈），我仍然相信人性总的来说是善良的",
+        "factor": "宜人性",
+        "reverse_scoring": False,
+    },
     {"id": 18, "content": "我觉得大部分人基本上是心怀善意的", "factor": "宜人性", "reverse_scoring": False},
     {"id": 19, "content": "虽然社会上有骗子，但我觉得大部分人还是可信的", "factor": "宜人性", "reverse_scoring": False},
     {"id": 20, "content": "我不太关心别人是否受到不公正的待遇", "factor": "宜人性", "reverse_scoring": True},
@@ -31,7 +38,6 @@ PERSONALITY_QUESTIONS = [
     {"id": 22, "content": "我常为那些遭遇不幸的人感到难过", "factor": "宜人性", "reverse_scoring": False},
     {"id": 23, "content": "我是那种只照顾好自己，不替别人担忧的人", "factor": "宜人性", "reverse_scoring": True},
     {"id": 24, "content": "当别人向我诉说不幸时，我常感到难过", "factor": "宜人性", "reverse_scoring": False},
-    
     # 开放性维度 (F4)
     {"id": 25, "content": "我的想象力相当丰富", "factor": "开放性", "reverse_scoring": False},
     {"id": 26, "content": "我头脑中经常充满生动的画面", "factor": "开放性", "reverse_scoring": False},
@@ -39,9 +45,18 @@ PERSONALITY_QUESTIONS = [
     {"id": 28, "content": "我喜欢冒险", "factor": "开放性", "reverse_scoring": False},
     {"id": 29, "content": "我是个勇于冒险，突破常规的人", "factor": "开放性", "reverse_scoring": False},
     {"id": 30, "content": "我身上具有别人没有的冒险精神", "factor": "开放性", "reverse_scoring": False},
-    {"id": 31, "content": "我渴望学习一些新东西，即使它们与我的日常生活无关", "factor": "开放性", "reverse_scoring": False},
+    {
-    {"id": 32, "content": "我很愿意也很容易接受那些新事物、新观点、新想法", "factor": "开放性", "reverse_scoring": False},
+        "id": 31,
-    
+        "content": "我渴望学习一些新东西，即使它们与我的日常生活无关",
+        "factor": "开放性",
+        "reverse_scoring": False,
+    },
+    {
+        "id": 32,
+        "content": "我很愿意也很容易接受那些新事物、新观点、新想法",
+        "factor": "开放性",
+        "reverse_scoring": False,
+    },
     # 外向性维度 (F5)
     {"id": 33, "content": "我喜欢参加社交与娱乐聚会", "factor": "外向性", "reverse_scoring": False},
     {"id": 34, "content": "我对人多的聚会感到乏味", "factor": "外向性", "reverse_scoring": True},
@@ -50,61 +65,78 @@ PERSONALITY_QUESTIONS = [
     {"id": 37, "content": "有我在的场合一般不会冷场", "factor": "外向性", "reverse_scoring": False},
     {"id": 38, "content": "我希望成为领导者而不是被领导者", "factor": "外向性", "reverse_scoring": False},
     {"id": 39, "content": "在一个团体中，我希望处于领导地位", "factor": "外向性", "reverse_scoring": False},
-    {"id": 40, "content": "别人多认为我是一个热情和友好的人", "factor": "外向性", "reverse_scoring": False}
+    {"id": 40, "content": "别人多认为我是一个热情和友好的人", "factor": "外向性", "reverse_scoring": False},
 ]
 
 # 因子维度说明
 FACTOR_DESCRIPTIONS = {
     "外向性": {
-        "description": "反映个体神经系统的强弱和动力特征。外向性主要表现为个体在人际交往和社交活动中的倾向性，包括对社交活动的兴趣、对人群的态度、社交互动中的主动程度以及在群体中的影响力。高分者倾向于积极参与社交活动，乐于与人交往，善于表达自我，并往往在群体中发挥领导作用；低分者则倾向于独处，不喜欢热闹的社交场合，表现出内向、安静的特征。",
+        "description": "反映个体神经系统的强弱和动力特征。外向性主要表现为个体在人际交往和社交活动中的倾向性，"
+        "包括对社交活动的兴趣、"
+        "对人群的态度、社交互动中的主动程度以及在群体中的影响力。高分者倾向于积极参与社交活动，乐于与人交往，善于表达自我，"
+        "并往往在群体中发挥领导作用；低分者则倾向于独处，不喜欢热闹的社交场合，表现出内向、安静的特征。",
         "trait_words": ["热情", "活力", "社交", "主动"],
         "subfactors": {
             "合群性": "个体愿意与他人聚在一起，即接近人群的倾向；高分表现乐群、好交际，低分表现封闭、独处",
             "热情": "个体对待别人时所表现出的态度；高分表现热情好客，低分表现冷淡",
             "支配性": "个体喜欢指使、操纵他人，倾向于领导别人的特点；高分表现好强、发号施令，低分表现顺从、低调",
-            "活跃": "个体精力充沛，活跃、主动性等特点；高分表现活跃，低分表现安静"
+            "活跃": "个体精力充沛，活跃、主动性等特点；高分表现活跃，低分表现安静",
-        }
+        },
     },
     "神经质": {
-        "description": "反映个体情绪的状态和体验内心苦恼的倾向性。这个维度主要关注个体在面对压力、挫折和日常生活挑战时的情绪稳定性和适应能力。它包含了对焦虑、抑郁、愤怒等负面情绪的敏感程度，以及个体对这些情绪的调节和控制能力。高分者容易体验负面情绪，对压力较为敏感，情绪波动较大；低分者则表现出较强的情绪稳定性，能够较好地应对压力和挫折。",
+        "description": "反映个体情绪的状态和体验内心苦恼的倾向性。这个维度主要关注个体在面对压力、"
+        "挫折和日常生活挑战时的情绪稳定性和适应能力。它包含了对焦虑、抑郁、愤怒等负面情绪的敏感程度，"
+        "以及个体对这些情绪的调节和控制能力。高分者容易体验负面情绪，对压力较为敏感，情绪波动较大；"
+        "低分者则表现出较强的情绪稳定性，能够较好地应对压力和挫折。",
         "trait_words": ["稳定", "沉着", "从容", "坚韧"],
         "subfactors": {
             "焦虑": "个体体验焦虑感的个体差异；高分表现坐立不安，低分表现平静",
             "抑郁": "个体体验抑郁情感的个体差异；高分表现郁郁寡欢，低分表现平静",
-            "敏感多疑": "个体常常关注自己的内心活动，行为和过于意识人对自己的看法、评价；高分表现敏感多疑，低分表现淡定、自信",
+            "敏感多疑": "个体常常关注自己的内心活动，行为和过于意识人对自己的看法、评价；高分表现敏感多疑，"
+            "低分表现淡定、自信",
             "脆弱性": "个体在危机或困难面前无力、脆弱的特点；高分表现无能、易受伤、逃避，低分表现坚强",
-            "愤怒-敌意": "个体准备体验愤怒，及相关情绪的状态；高分表现暴躁易怒，低分表现平静"
+            "愤怒-敌意": "个体准备体验愤怒，及相关情绪的状态；高分表现暴躁易怒，低分表现平静",
-        }
+        },
     },
     "严谨性": {
-        "description": "反映个体在目标导向行为上的组织、坚持和动机特征。这个维度体现了个体在工作、学习等目标性活动中的自我约束和行为管理能力。它涉及到个体的责任感、自律性、计划性、条理性以及完成任务的态度。高分者往往表现出强烈的责任心、良好的组织能力、谨慎的决策风格和持续的努力精神；低分者则可能表现出随意性强、缺乏规划、做事马虎或易放弃的特点。",
+        "description": "反映个体在目标导向行为上的组织、坚持和动机特征。这个维度体现了个体在工作、"
+        "学习等目标性活动中的自我约束和行为管理能力。它涉及到个体的责任感、自律性、计划性、条理性以及完成任务的态度。"
+        "高分者往往表现出强烈的责任心、良好的组织能力、谨慎的决策风格和持续的努力精神；低分者则可能表现出随意性强、"
+        "缺乏规划、做事马虎或易放弃的特点。",
         "trait_words": ["负责", "自律", "条理", "勤奋"],
         "subfactors": {
-            "责任心": "个体对待任务和他人认真负责，以及对自己承诺的信守；高分表现有责任心、负责任，低分表现推卸责任、逃避处罚",
+            "责任心": "个体对待任务和他人认真负责，以及对自己承诺的信守；高分表现有责任心、负责任，"
+            "低分表现推卸责任、逃避处罚",
             "自我控制": "个体约束自己的能力，及自始至终的坚持性；高分表现自制、有毅力，低分表现冲动、无毅力",
             "审慎性": "个体在采取具体行动前的心理状态；高分表现谨慎、小心，低分表现鲁莽、草率",
             "条理性": "个体处理事务和工作的秩序，条理和逻辑性；高分表现整洁、有秩序，低分表现混乱、遗漏",
-            "勤奋": "个体工作和学习的努力程度及为达到目标而表现出的进取精神；高分表现勤奋、刻苦，低分表现懒散"
+            "勤奋": "个体工作和学习的努力程度及为达到目标而表现出的进取精神；高分表现勤奋、刻苦，低分表现懒散",
-        }
+        },
     },
     "开放性": {
-        "description": "反映个体对新异事物、新观念和新经验的接受程度，以及在思维和行为方面的创新倾向。这个维度体现了个体在认知和体验方面的广度、深度和灵活性。它包括对艺术的欣赏能力、对知识的求知欲、想象力的丰富程度，以及对冒险和创新的态度。高分者往往具有丰富的想象力、广泛的兴趣、开放的思维方式和创新的倾向；低分者则倾向于保守、传统，喜欢熟悉和常规的事物。",
+        "description": "反映个体对新异事物、新观念和新经验的接受程度，以及在思维和行为方面的创新倾向。"
+        "这个维度体现了个体在认知和体验方面的广度、深度和灵活性。它包括对艺术的欣赏能力、对知识的求知欲、想象力的丰富程度，"
+        "以及对冒险和创新的态度。高分者往往具有丰富的想象力、广泛的兴趣、开放的思维方式和创新的倾向；低分者则倾向于保守、"
+        "传统，喜欢熟悉和常规的事物。",
         "trait_words": ["创新", "好奇", "艺术", "冒险"],
         "subfactors": {
             "幻想": "个体富于幻想和想象的水平；高分表现想象力丰富，低分表现想象力匮乏",
             "审美": "个体对于艺术和美的敏感与热爱程度；高分表现富有艺术气息，低分表现一般对艺术不敏感",
             "好奇心": "个体对未知事物的态度；高分表现兴趣广泛、好奇心浓，低分表现兴趣少、无好奇心",
             "冒险精神": "个体愿意尝试有风险活动的个体差异；高分表现好冒险，低分表现保守",
-            "价值观念": "个体对新事物、新观念、怪异想法的态度；高分表现开放、坦然接受新事物，低分则相反"
+            "价值观念": "个体对新事物、新观念、怪异想法的态度；高分表现开放、坦然接受新事物，低分则相反",
-        }
+        },
     },
     "宜人性": {
-        "description": "反映个体在人际关系中的亲和倾向，体现了对他人的关心、同情和合作意愿。这个维度主要关注个体与他人互动时的态度和行为特征，包括对他人的信任程度、同理心水平、助人意愿以及在人际冲突中的处理方式。高分者通常表现出友善、富有同情心、乐于助人的特质，善于与他人建立和谐关系；低分者则可能表现出较少的人际关注，在社交互动中更注重自身利益，较少考虑他人感受。",
+        "description": "反映个体在人际关系中的亲和倾向，体现了对他人的关心、同情和合作意愿。"
+        "这个维度主要关注个体与他人互动时的态度和行为特征，包括对他人的信任程度、同理心水平、"
+        "助人意愿以及在人际冲突中的处理方式。高分者通常表现出友善、富有同情心、乐于助人的特质，善于与他人建立和谐关系；"
+        "低分者则可能表现出较少的人际关注，在社交互动中更注重自身利益，较少考虑他人感受。",
         "trait_words": ["友善", "同理", "信任", "合作"],
         "subfactors": {
             "信任": "个体对他人和/或他人言论的相信程度；高分表现信任他人，低分表现怀疑",
             "体贴": "个体对别人的兴趣和需要的关注程度；高分表现体贴、温存，低分表现冷漠、不在乎",
-            "同情": "个体对处于不利地位的人或物的态度；高分表现富有同情心，低分表现冷漠"
+            "同情": "个体对处于不利地位的人或物的态度；高分表现富有同情心，低分表现冷漠",
-        }
+        },
-    }
+    },
-} 
+}

src/plugins/personality/renqingziji.py

@@ -1,10 +1,12 @@
-'''
+"""
-The definition of artificial personality in this paper follows the dispositional para-digm and adapts a definition of personality developed for humans [17]: 
+The definition of artificial personality in this paper follows the dispositional para-digm and adapts a definition of
-Personality for a human is the "whole and organisation of relatively stable tendencies and patterns of experience and 
+personality developed for humans [17]:
-behaviour within one person (distinguishing it from other persons)". This definition is modified for artificial personality: 
+Personality for a human is the "whole and organisation of relatively stable tendencies and patterns of experience and
-Artificial personality describes the relatively stable tendencies and patterns of behav-iour of an AI-based machine that 
+behaviour within one person (distinguishing it from other persons)". This definition is modified for artificial
-can be designed by developers and designers via different modalities, such as language, creating the impression 
+personality:
-of individuality of a humanized social agent when users interact with the machine.'''
+Artificial personality describes the relatively stable tendencies and patterns of behav-iour of an AI-based machine that
+can be designed by developers and designers via different modalities, such as language, creating the impression
+of individuality of a humanized social agent when users interact with the machine."""
 
 from typing import Dict, List
 import json
@@ -13,9 +15,9 @@ from pathlib import Path
 from dotenv import load_dotenv
 import sys
 
-'''
+"""
 第一种方案：基于情景评估的人格测定
-'''
+"""
 current_dir = Path(__file__).resolve().parent
 project_root = current_dir.parent.parent.parent
 env_path = project_root / ".env.prod"
@@ -23,9 +25,9 @@ env_path = project_root / ".env.prod"
 root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
 sys.path.append(root_path)
 
-from src.plugins.personality.scene import get_scene_by_factor,get_all_scenes,PERSONALITY_SCENES
+from src.plugins.personality.scene import get_scene_by_factor, PERSONALITY_SCENES  # noqa: E402
-from src.plugins.personality.questionnaire import PERSONALITY_QUESTIONS,FACTOR_DESCRIPTIONS
+from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS  # noqa: E402
-from src.plugins.personality.offline_llm import LLMModel 
+from src.plugins.personality.offline_llm import LLMModel  # noqa: E402
 
 # 加载环境变量
 if env_path.exists():
@@ -40,32 +42,31 @@ class PersonalityEvaluator_direct:
     def __init__(self):
         self.personality_traits = {"开放性": 0, "严谨性": 0, "外向性": 0, "宜人性": 0, "神经质": 0}
         self.scenarios = []
-        
+
         # 为每个人格特质获取对应的场景
         for trait in PERSONALITY_SCENES:
             scenes = get_scene_by_factor(trait)
             if not scenes:
                 continue
-                
+
             # 从每个维度选择3个场景
             import random
+
             scene_keys = list(scenes.keys())
             selected_scenes = random.sample(scene_keys, min(3, len(scene_keys)))
-            
+
             for scene_key in selected_scenes:
                 scene = scenes[scene_key]
-                
+
                 # 为每个场景添加评估维度
                 # 主维度是当前特质，次维度随机选择一个其他特质
                 other_traits = [t for t in PERSONALITY_SCENES if t != trait]
                 secondary_trait = random.choice(other_traits)
-                
+
-                self.scenarios.append({
+                self.scenarios.append(
-                    "场景": scene["scenario"],
+                    {"场景": scene["scenario"], "评估维度": [trait, secondary_trait], "场景编号": scene_key}
-                    "评估维度": [trait, secondary_trait],
+                )
-                    "场景编号": scene_key
+
-                })
-            
         self.llm = LLMModel()
 
     def evaluate_response(self, scenario: str, response: str, dimensions: List[str]) -> Dict[str, float]:
@@ -78,9 +79,9 @@ class PersonalityEvaluator_direct:
             desc = FACTOR_DESCRIPTIONS.get(dim, "")
             if desc:
                 dimension_descriptions.append(f"- {dim}：{desc}")
-        
+
         dimensions_text = "\n".join(dimension_descriptions)
-        
+
         prompt = f"""请根据以下场景和用户描述，评估用户在大五人格模型中的相关维度得分（1-6分）。
 
 场景描述：
@@ -178,11 +179,7 @@ def main():
         print(f"测试场景数：{dimension_counts[trait]}")
 
     # 保存结果
-    result = {
+    result = {"final_scores": final_scores, "dimension_counts": dimension_counts, "scenarios": evaluator.scenarios}
-        "final_scores": final_scores, 
-        "dimension_counts": dimension_counts,
-        "scenarios": evaluator.scenarios
-    }
 
     # 确保目录存在
     os.makedirs("results", exist_ok=True)

src/plugins/personality/scene.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict
 
 PERSONALITY_SCENES = {
     "外向性": {
@@ -8,7 +8,7 @@ PERSONALITY_SCENES = {
 同事：「嗨！你是新来的同事吧？我是市场部的小林。」
 
 同事看起来很友善，还主动介绍说：「待会午饭时间，我们部门有几个人准备一起去楼下新开的餐厅，你要一起来吗？可以认识一下其他同事。」""",
-            "explanation": "这个场景通过职场社交情境，观察个体对于新环境、新社交圈的态度和反应倾向。"
+            "explanation": "这个场景通过职场社交情境，观察个体对于新环境、新社交圈的态度和反应倾向。",
         },
         "场景2": {
             "scenario": """在大学班级群里，班长发起了一个组织班级联谊活动的投票：
@@ -16,7 +16,7 @@ PERSONALITY_SCENES = {
 班长：「大家好！下周末我们准备举办一次班级联谊活动，地点在学校附近的KTV。想请大家报名参加，也欢迎大家邀请其他班级的同学！」
 
 已经有几个同学在群里积极响应，有人@你问你要不要一起参加。""",
-            "explanation": "通过班级活动场景，观察个体对群体社交活动的参与意愿。"
+            "explanation": "通过班级活动场景，观察个体对群体社交活动的参与意愿。",
         },
         "场景3": {
             "scenario": """你在社交平台上发布了一条动态，收到了很多陌生网友的评论和私信：
@@ -24,13 +24,14 @@ PERSONALITY_SCENES = {
 网友A：「你说的这个观点很有意思！想和你多交流一下。」
 
 网友B：「我也对这个话题很感兴趣，要不要建个群一起讨论？」""",
-            "explanation": "通过网络社交场景，观察个体对线上社交的态度。"
+            "explanation": "通过网络社交场景，观察个体对线上社交的态度。",
         },
         "场景4": {
             "scenario": """你暗恋的对象今天主动来找你：
 
-对方：「那个...我最近在准备一个演讲比赛，听说你口才很好。能不能请你帮我看看演讲稿，顺便给我一些建议？如果你有时间的话，可以一起吃个饭聊聊。」""",
+对方：「那个...我最近在准备一个演讲比赛，听说你口才很好。能不能请你帮我看看演讲稿，顺便给我一些建议？"""
-            "explanation": "通过恋爱情境，观察个体在面对心仪对象时的社交表现。"
+            """如果你有时间的话，可以一起吃个饭聊聊。」""",
+            "explanation": "通过恋爱情境，观察个体在面对心仪对象时的社交表现。",
         },
         "场景5": {
             "scenario": """在一次线下读书会上，主持人突然点名让你分享读后感：
@@ -38,18 +39,18 @@ PERSONALITY_SCENES = {
 主持人：「听说你对这本书很有见解，能不能和大家分享一下你的想法？」
 
 现场有二十多个陌生的读书爱好者，都期待地看着你。""",
-            "explanation": "通过即兴发言场景，观察个体的社交表现欲和公众表达能力。"
+            "explanation": "通过即兴发言场景，观察个体的社交表现欲和公众表达能力。",
-        }
+        },
     },
-    
     "神经质": {
         "场景1": {
-            "scenario": """你正在准备一个重要的项目演示，这关系到你的晋升机会。就在演示前30分钟，你收到了主管发来的消息：
+            "scenario": """你正在准备一个重要的项目演示，这关系到你的晋升机会。"""
+            """就在演示前30分钟，你收到了主管发来的消息：
 
 主管：「临时有个变动，CEO也会来听你的演示。他对这个项目特别感兴趣。」
 
 正当你准备回复时，主管又发来一条：「对了，能不能把演示时间压缩到15分钟？CEO下午还有其他安排。你之前准备的是30分钟的版本对吧？」""",
-            "explanation": "这个场景通过突发的压力情境，观察个体在面对计划外变化时的情绪反应和调节能力。"
+            "explanation": "这个场景通过突发的压力情境，观察个体在面对计划外变化时的情绪反应和调节能力。",
         },
         "场景2": {
             "scenario": """期末考试前一天晚上，你收到了好朋友发来的消息：
@@ -57,7 +58,7 @@ PERSONALITY_SCENES = {
 好朋友：「不好意思这么晚打扰你...我看你平时成绩很好，能不能帮我解答几个问题？我真的很担心明天的考试。」
 
 你看了看时间，已经是晚上11点，而你原本计划的复习还没完成。""",
-            "explanation": "通过考试压力场景，观察个体在时间紧张时的情绪管理。"
+            "explanation": "通过考试压力场景，观察个体在时间紧张时的情绪管理。",
         },
         "场景3": {
             "scenario": """你在社交媒体上发表的一个观点引发了争议，有不少人开始批评你：
@@ -67,7 +68,7 @@ PERSONALITY_SCENES = {
 网友B：「建议楼主先去补补课再来发言。」
 
 评论区里的负面评论越来越多，还有人开始人身攻击。""",
-            "explanation": "通过网络争议场景，观察个体面对批评时的心理承受能力。"
+            "explanation": "通过网络争议场景，观察个体面对批评时的心理承受能力。",
         },
         "场景4": {
             "scenario": """你和恋人约好今天一起看电影，但在约定时间前半小时，对方发来消息：
@@ -77,7 +78,7 @@ PERSONALITY_SCENES = {
 二十分钟后，对方又发来消息：「可能要再等等，抱歉！」
 
 电影快要开始了，但对方还是没有出现。""",
-            "explanation": "通过恋爱情境，观察个体对不确定性的忍耐程度。"
+            "explanation": "通过恋爱情境，观察个体对不确定性的忍耐程度。",
         },
         "场景5": {
             "scenario": """在一次重要的小组展示中，你的组员在演示途中突然卡壳了：
@@ -85,10 +86,9 @@ PERSONALITY_SCENES = {
 组员小声对你说：「我忘词了，接下来的部分是什么来着...」
 
 台下的老师和同学都在等待，气氛有些尴尬。""",
-            "explanation": "通过公开场合的突发状况，观察个体的应急反应和压力处理能力。"
+            "explanation": "通过公开场合的突发状况，观察个体的应急反应和压力处理能力。",
-        }
+        },
     },
-    
     "严谨性": {
         "场景1": {
             "scenario": """你是团队的项目负责人，刚刚接手了一个为期两个月的重要项目。在第一次团队会议上：
@@ -98,7 +98,7 @@ PERSONALITY_SCENES = {
 小张：「要不要先列个时间表？不过感觉太详细的计划也没必要，点到为止就行。」
 
 小李：「客户那边说如果能提前完成有奖励，我觉得我们可以先做快一点的部分。」""",
-            "explanation": "这个场景通过项目管理情境，体现个体在工作方法、计划性和责任心方面的特征。"
+            "explanation": "这个场景通过项目管理情境，体现个体在工作方法、计划性和责任心方面的特征。",
         },
         "场景2": {
             "scenario": """期末小组作业，组长让大家分工完成一份研究报告。在截止日期前三天：
@@ -108,7 +108,7 @@ PERSONALITY_SCENES = {
 组员B：「我这边可能还要一天才能完成，最近太忙了。」
 
 组员C发来一份没有任何引用出处、可能存在抄袭的内容：「我写完了，你们看看怎么样？」""",
-            "explanation": "通过学习场景，观察个体对学术规范和质量要求的重视程度。"
+            "explanation": "通过学习场景，观察个体对学术规范和质量要求的重视程度。",
         },
         "场景3": {
             "scenario": """你在一个兴趣小组的群聊中，大家正在讨论举办一次线下活动：
@@ -118,7 +118,7 @@ PERSONALITY_SCENES = {
 成员B：「对啊，随意一点挺好的。」
 
 成员C：「人来了自然就热闹了。」""",
-            "explanation": "通过活动组织场景，观察个体对活动计划的态度。"
+            "explanation": "通过活动组织场景，观察个体对活动计划的态度。",
         },
         "场景4": {
             "scenario": """你和恋人计划一起去旅游，对方说：
@@ -126,7 +126,7 @@ PERSONALITY_SCENES = {
 恋人：「我们就随心而行吧！订个目的地，其他的到了再说，这样更有意思。」
 
 距离出发还有一周时间，但机票、住宿和具体行程都还没有确定。""",
-            "explanation": "通过旅行规划场景，观察个体的计划性和对不确定性的接受程度。"
+            "explanation": "通过旅行规划场景，观察个体的计划性和对不确定性的接受程度。",
         },
         "场景5": {
             "scenario": """在一个重要的团队项目中，你发现一个同事的工作存在明显错误：
@@ -134,18 +134,19 @@ PERSONALITY_SCENES = {
 同事：「差不多就行了，反正领导也看不出来。」
 
 这个错误可能不会立即造成问题，但长期来看可能会影响项目质量。""",
-            "explanation": "通过工作质量场景，观察个体对细节和标准的坚持程度。"
+            "explanation": "通过工作质量场景，观察个体对细节和标准的坚持程度。",
-        }
+        },
     },
-    
     "开放性": {
         "场景1": {
             "scenario": """周末下午，你的好友小美兴致勃勃地给你打电话：
 
-小美：「我刚发现一个特别有意思的沉浸式艺术展！不是传统那种挂画的展览，而是把整个空间都变成了艺术品。观众要穿特制的服装，还要带上VR眼镜，好像还有AI实时互动！」
+小美：「我刚发现一个特别有意思的沉浸式艺术展！不是传统那种挂画的展览，而是把整个空间都变成了艺术品。"""
+            """观众要穿特制的服装，还要带上VR眼镜，好像还有AI实时互动！」
 
-小美继续说：「虽然票价不便宜，但听说体验很独特。网上评价两极分化，有人说是前所未有的艺术革新，也有人说是哗众取宠。要不要周末一起去体验一下？」""",
+小美继续说：「虽然票价不便宜，但听说体验很独特。网上评价两极分化，有人说是前所未有的艺术革新，也有人说是哗众取宠。"""
-            "explanation": "这个场景通过新型艺术体验，反映个体对创新事物的接受程度和尝试意愿。"
+            """要不要周末一起去体验一下？」""",
+            "explanation": "这个场景通过新型艺术体验，反映个体对创新事物的接受程度和尝试意愿。",
         },
         "场景2": {
             "scenario": """在一节创意写作课上，老师提出了一个特别的作业：
@@ -153,15 +154,16 @@ PERSONALITY_SCENES = {
 老师：「下周的作业是用AI写作工具协助创作一篇小说。你们可以自由探索如何与AI合作，打破传统写作方式。」
 
 班上随即展开了激烈讨论，有人认为这是对创作的亵渎，也有人对这种新形式感到兴奋。""",
-            "explanation": "通过新技术应用场景，观察个体对创新学习方式的态度。"
+            "explanation": "通过新技术应用场景，观察个体对创新学习方式的态度。",
         },
         "场景3": {
             "scenario": """在社交媒体上，你看到一个朋友分享了一种新的生活方式：
 
-「最近我在尝试'数字游牧'生活，就是一边远程工作一边环游世界。没有固定住所，住青旅或短租，认识来自世界各地的朋友。虽然有时会很不稳定，但这种自由的生活方式真的很棒！」
+「最近我在尝试'数字游牧'生活，就是一边远程工作一边环游世界。"""
+            """没有固定住所，住青旅或短租，认识来自世界各地的朋友。虽然有时会很不稳定，但这种自由的生活方式真的很棒！」
 
 评论区里争论不断，有人向往这种生活，也有人觉得太冒险。""",
-            "explanation": "通过另类生活方式，观察个体对非传统选择的态度。"
+            "explanation": "通过另类生活方式，观察个体对非传统选择的态度。",
         },
         "场景4": {
             "scenario": """你的恋人突然提出了一个想法：
@@ -169,7 +171,7 @@ PERSONALITY_SCENES = {
 恋人：「我们要不要尝试一下开放式关系？就是在保持彼此关系的同时，也允许和其他人发展感情。现在国外很多年轻人都这样。」
 
 这个提议让你感到意外，你之前从未考虑过这种可能性。""",
-            "explanation": "通过感情观念场景，观察个体对非传统关系模式的接受度。"
+            "explanation": "通过感情观念场景，观察个体对非传统关系模式的接受度。",
         },
         "场景5": {
             "scenario": """在一次朋友聚会上，大家正在讨论未来职业规划：
@@ -179,10 +181,9 @@ PERSONALITY_SCENES = {
 朋友B：「我想去学习生物科技，准备转行做人造肉研发。」
 
 朋友C：「我在考虑加入一个区块链创业项目，虽然风险很大。」""",
-            "explanation": "通过职业选择场景，观察个体对新兴领域的探索意愿。"
+            "explanation": "通过职业选择场景，观察个体对新兴领域的探索意愿。",
-        }
+        },
     },
-    
     "宜人性": {
         "场景1": {
             "scenario": """在回家的公交车上，你遇到这样一幕：
@@ -194,7 +195,7 @@ PERSONALITY_SCENES = {
 年轻人B：「现在的老年人真是...我看她包里还有菜，肯定是去菜市场买完菜回来的，这么多人都不知道叫子女开车接送。」
 
 就在这时，老奶奶一个趔趄，差点摔倒。她扶住了扶手，但包里的东西洒了一些出来。""",
-            "explanation": "这个场景通过公共场合的助人情境，体现个体的同理心和对他人需求的关注程度。"
+            "explanation": "这个场景通过公共场合的助人情境，体现个体的同理心和对他人需求的关注程度。",
         },
         "场景2": {
             "scenario": """在班级群里，有同学发起为生病住院的同学捐款：
@@ -204,7 +205,7 @@ PERSONALITY_SCENES = {
 同学B：「我觉得这是他家里的事，我们不方便参与吧。」
 
 同学C：「但是都是同学一场，帮帮忙也是应该的。」""",
-            "explanation": "通过同学互助场景，观察个体的助人意愿和同理心。"
+            "explanation": "通过同学互助场景，观察个体的助人意愿和同理心。",
         },
         "场景3": {
             "scenario": """在一个网络讨论组里，有人发布了求助信息：
@@ -215,7 +216,7 @@ PERSONALITY_SCENES = {
 「生活本来就是这样，想开点！」
 「你这样子太消极了，要积极面对。」
 「谁还没点烦心事啊，过段时间就好了。」""",
-            "explanation": "通过网络互助场景，观察个体的共情能力和安慰方式。"
+            "explanation": "通过网络互助场景，观察个体的共情能力和安慰方式。",
         },
         "场景4": {
             "scenario": """你的恋人向你倾诉工作压力：
@@ -223,7 +224,7 @@ PERSONALITY_SCENES = {
 恋人：「最近工作真的好累，感觉快坚持不下去了...」
 
 但今天你也遇到了很多烦心事，心情也不太好。""",
-            "explanation": "通过感情关系场景，观察个体在自身状态不佳时的关怀能力。"
+            "explanation": "通过感情关系场景，观察个体在自身状态不佳时的关怀能力。",
         },
         "场景5": {
             "scenario": """在一次团队项目中，新来的同事小王因为经验不足，造成了一个严重的错误。在部门会议上：
@@ -231,27 +232,29 @@ PERSONALITY_SCENES = {
 主管：「这个错误造成了很大的损失，是谁负责的这部分？」
 
 小王看起来很紧张，欲言又止。你知道是他造成的错误，同时你也是这个项目的共同负责人。""",
-            "explanation": "通过职场情境，观察个体在面对他人过错时的态度和处理方式。"
+            "explanation": "通过职场情境，观察个体在面对他人过错时的态度和处理方式。",
-        }
+        },
-    }
+    },
 }
 
+
 def get_scene_by_factor(factor: str) -> Dict:
     """
     根据人格因子获取对应的情景测试
-    
+
     Args:
         factor (str): 人格因子名称
-        
+
     Returns:
         Dict: 包含情景描述的字典
     """
     return PERSONALITY_SCENES.get(factor, None)
 
+
 def get_all_scenes() -> Dict:
     """
     获取所有情景测试
-    
+
     Returns:
         Dict: 所有情景测试的字典
     """

src/plugins/schedule/offline_llm.py

@@ -0,0 +1,123 @@
+import asyncio
+import os
+import time
+from typing import Tuple, Union
+
+import aiohttp
+import requests
+from src.common.logger import get_module_logger
+
+logger = get_module_logger("offline_llm")
+
+
+class LLMModel:
+    def __init__(self, model_name="deepseek-ai/DeepSeek-V3", **kwargs):
+        self.model_name = model_name
+        self.params = kwargs
+        self.api_key = os.getenv("SILICONFLOW_KEY")
+        self.base_url = os.getenv("SILICONFLOW_BASE_URL")
+
+        if not self.api_key or not self.base_url:
+            raise ValueError("环境变量未正确加载：SILICONFLOW_KEY 或 SILICONFLOW_BASE_URL 未设置")
+
+        logger.info(f"API URL: {self.base_url}")  # 使用 logger 记录 base_url
+
+    def generate_response(self, prompt: str) -> Union[str, Tuple[str, str]]:
+        """根据输入的提示生成模型的响应"""
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+        # 构建请求体
+        data = {
+            "model": self.model_name,
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.5,
+            **self.params,
+        }
+
+        # 发送请求到完整的 chat/completions 端点
+        api_url = f"{self.base_url.rstrip('/')}/chat/completions"
+        logger.info(f"Request URL: {api_url}")  # 记录请求的 URL
+
+        max_retries = 3
+        base_wait_time = 15  # 基础等待时间（秒）
+
+        for retry in range(max_retries):
+            try:
+                response = requests.post(api_url, headers=headers, json=data)
+
+                if response.status_code == 429:
+                    wait_time = base_wait_time * (2**retry)  # 指数退避
+                    logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
+                    time.sleep(wait_time)
+                    continue
+
+                response.raise_for_status()  # 检查其他响应状态
+
+                result = response.json()
+                if "choices" in result and len(result["choices"]) > 0:
+                    content = result["choices"][0]["message"]["content"]
+                    reasoning_content = result["choices"][0]["message"].get("reasoning_content", "")
+                    return content, reasoning_content
+                return "没有返回结果", ""
+
+            except Exception as e:
+                if retry < max_retries - 1:  # 如果还有重试机会
+                    wait_time = base_wait_time * (2**retry)
+                    logger.error(f"[回复]请求失败，等待{wait_time}秒后重试... 错误: {str(e)}")
+                    time.sleep(wait_time)
+                else:
+                    logger.error(f"请求失败: {str(e)}")
+                    return f"请求失败: {str(e)}", ""
+
+        logger.error("达到最大重试次数，请求仍然失败")
+        return "达到最大重试次数，请求仍然失败", ""
+
+    async def generate_response_async(self, prompt: str) -> Union[str, Tuple[str, str]]:
+        """异步方式根据输入的提示生成模型的响应"""
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+
+        # 构建请求体
+        data = {
+            "model": self.model_name,
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.5,
+            **self.params,
+        }
+
+        # 发送请求到完整的 chat/completions 端点
+        api_url = f"{self.base_url.rstrip('/')}/chat/completions"
+        logger.info(f"Request URL: {api_url}")  # 记录请求的 URL
+
+        max_retries = 3
+        base_wait_time = 15
+
+        async with aiohttp.ClientSession() as session:
+            for retry in range(max_retries):
+                try:
+                    async with session.post(api_url, headers=headers, json=data) as response:
+                        if response.status == 429:
+                            wait_time = base_wait_time * (2**retry)  # 指数退避
+                            logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
+                            await asyncio.sleep(wait_time)
+                            continue
+
+                        response.raise_for_status()  # 检查其他响应状态
+
+                        result = await response.json()
+                        if "choices" in result and len(result["choices"]) > 0:
+                            content = result["choices"][0]["message"]["content"]
+                            reasoning_content = result["choices"][0]["message"].get("reasoning_content", "")
+                            return content, reasoning_content
+                        return "没有返回结果", ""
+
+                except Exception as e:
+                    if retry < max_retries - 1:  # 如果还有重试机会
+                        wait_time = base_wait_time * (2**retry)
+                        logger.error(f"[回复]请求失败，等待{wait_time}秒后重试... 错误: {str(e)}")
+                        await asyncio.sleep(wait_time)
+                    else:
+                        logger.error(f"请求失败: {str(e)}")
+                        return f"请求失败: {str(e)}", ""
+
+            logger.error("达到最大重试次数，请求仍然失败")
+            return "达到最大重试次数，请求仍然失败", ""

src/plugins/schedule/schedule_generator copy.py

@@ -0,0 +1,191 @@
+import datetime
+import json
+import re
+import os
+import sys
+from typing import Dict, Union
+
+
+# 添加项目根目录到 Python 路径
+root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
+sys.path.append(root_path)
+
+from src.common.database import db # noqa: E402
+from src.common.logger import get_module_logger # noqa: E402
+from src.plugins.schedule.offline_llm import LLMModel # noqa: E402
+from src.plugins.chat.config import global_config # noqa: E402
+
+logger = get_module_logger("scheduler")
+
+
+class ScheduleGenerator:
+    enable_output: bool = True
+
+    def __init__(self):
+        # 使用离线LLM模型
+        self.llm_scheduler = LLMModel(model_name="Pro/deepseek-ai/DeepSeek-V3", temperature=0.9)
+        self.today_schedule_text = ""
+        self.today_schedule = {}
+        self.tomorrow_schedule_text = ""
+        self.tomorrow_schedule = {}
+        self.yesterday_schedule_text = ""
+        self.yesterday_schedule = {}
+
+    async def initialize(self):
+        today = datetime.datetime.now()
+        tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
+        yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
+
+        self.today_schedule_text, self.today_schedule = await self.generate_daily_schedule(target_date=today)
+        self.tomorrow_schedule_text, self.tomorrow_schedule = await self.generate_daily_schedule(
+            target_date=tomorrow, read_only=True
+        )
+        self.yesterday_schedule_text, self.yesterday_schedule = await self.generate_daily_schedule(
+            target_date=yesterday, read_only=True
+        )
+
+    async def generate_daily_schedule(
+        self, target_date: datetime.datetime = None, read_only: bool = False
+    ) -> Dict[str, str]:
+        date_str = target_date.strftime("%Y-%m-%d")
+        weekday = target_date.strftime("%A")
+
+        schedule_text = str
+
+        existing_schedule = db.schedule.find_one({"date": date_str})
+        if existing_schedule:
+            if self.enable_output:
+                logger.debug(f"{date_str}的日程已存在:")
+            schedule_text = existing_schedule["schedule"]
+            # print(self.schedule_text)
+
+        elif not read_only:
+            logger.debug(f"{date_str}的日程不存在，准备生成新的日程。")
+            prompt = (
+                f"""我是{global_config.BOT_NICKNAME}，{global_config.PROMPT_SCHEDULE_GEN}，请为我生成{date_str}（{weekday}）的日程安排，包括："""
+                + """
+            1. 早上的学习和工作安排
+            2. 下午的活动和任务
+            3. 晚上的计划和休息时间
+            请按照时间顺序列出具体时间点和对应的活动，用一个时间点而不是时间段来表示时间，用JSON格式返回日程表，
+            仅返回内容，不要返回注释，不要添加任何markdown或代码块样式，时间采用24小时制，
+            格式为{"时间": "活动","时间": "活动",...}。"""
+            )
+
+            try:
+                schedule_text, _ = self.llm_scheduler.generate_response(prompt)
+                db.schedule.insert_one({"date": date_str, "schedule": schedule_text})
+                self.enable_output = True
+            except Exception as e:
+                logger.error(f"生成日程失败: {str(e)}")
+                schedule_text = "生成日程时出错了"
+            # print(self.schedule_text)
+        else:
+            if self.enable_output:
+                logger.debug(f"{date_str}的日程不存在。")
+            schedule_text = "忘了"
+
+            return schedule_text, None
+
+        schedule_form = self._parse_schedule(schedule_text)
+        return schedule_text, schedule_form
+
+    def _parse_schedule(self, schedule_text: str) -> Union[bool, Dict[str, str]]:
+        """解析日程文本，转换为时间和活动的字典"""
+        try:
+            reg = r"\{(.|\r|\n)+\}"
+            matched = re.search(reg, schedule_text)[0]
+            schedule_dict = json.loads(matched)
+            return schedule_dict
+        except json.JSONDecodeError:
+            logger.exception("解析日程失败: {}".format(schedule_text))
+            return False
+
+    def _parse_time(self, time_str: str) -> str:
+        """解析时间字符串，转换为时间"""
+        return datetime.datetime.strptime(time_str, "%H:%M")
+
+    def get_current_task(self) -> str:
+        """获取当前时间应该进行的任务"""
+        current_time = datetime.datetime.now().strftime("%H:%M")
+
+        # 找到最接近当前时间的任务
+        closest_time = None
+        min_diff = float("inf")
+
+        # 检查今天的日程
+        if not self.today_schedule:
+            return "摸鱼"
+        for time_str in self.today_schedule.keys():
+            diff = abs(self._time_diff(current_time, time_str))
+            if closest_time is None or diff < min_diff:
+                closest_time = time_str
+                min_diff = diff
+
+        # 检查昨天的日程中的晚间任务
+        if self.yesterday_schedule:
+            for time_str in self.yesterday_schedule.keys():
+                if time_str >= "20:00":  # 只考虑晚上8点之后的任务
+                    # 计算与昨天这个时间点的差异（需要加24小时）
+                    diff = abs(self._time_diff(current_time, time_str))
+                    if diff < min_diff:
+                        closest_time = time_str
+                        min_diff = diff
+                        return closest_time, self.yesterday_schedule[closest_time]
+
+        if closest_time:
+            return closest_time, self.today_schedule[closest_time]
+        return "摸鱼"
+
+    def _time_diff(self, time1: str, time2: str) -> int:
+        """计算两个时间字符串之间的分钟差"""
+        if time1 == "24:00":
+            time1 = "23:59"
+        if time2 == "24:00":
+            time2 = "23:59"
+        t1 = datetime.datetime.strptime(time1, "%H:%M")
+        t2 = datetime.datetime.strptime(time2, "%H:%M")
+        diff = int((t2 - t1).total_seconds() / 60)
+        # 考虑时间的循环性
+        if diff < -720:
+            diff += 1440  # 加一天的分钟
+        elif diff > 720:
+            diff -= 1440  # 减一天的分钟
+        # print(f"时间1[{time1}]: 时间2[{time2}]，差值[{diff}]分钟")
+        return diff
+
+    def print_schedule(self):
+        """打印完整的日程安排"""
+        if not self._parse_schedule(self.today_schedule_text):
+            logger.warning("今日日程有误，将在下次运行时重新生成")
+            db.schedule.delete_one({"date": datetime.datetime.now().strftime("%Y-%m-%d")})
+        else:
+            logger.info("=== 今日日程安排 ===")
+            for time_str, activity in self.today_schedule.items():
+                logger.info(f"时间[{time_str}]: 活动[{activity}]")
+            logger.info("==================")
+            self.enable_output = False
+
+
+async def main():
+    # 使用示例
+    scheduler = ScheduleGenerator()
+    await scheduler.initialize()
+    scheduler.print_schedule()
+    print("\n当前任务：")
+    print(await scheduler.get_current_task())
+
+    print("昨天日程：")
+    print(scheduler.yesterday_schedule)
+    print("今天日程：")
+    print(scheduler.today_schedule)
+    print("明天日程：")
+    print(scheduler.tomorrow_schedule)
+
+# 当作为组件导入时使用的实例
+bot_schedule = ScheduleGenerator()
+
+if __name__ == "__main__":
+    import asyncio
+    # 当直接运行此文件时执行
+    asyncio.run(main())

src/plugins/schedule/schedule_generator.py

@@ -5,8 +5,9 @@ from typing import Dict, Union
 
 from nonebot import get_driver
 
-from src.plugins.chat.config import global_config
+# 添加项目根目录到 Python 路径
 
+from src.plugins.chat.config import global_config
 from ...common.database import db  # 使用正确的导入语法
 from ..models.utils_model import LLM_request
 from src.common.logger import get_module_logger
@@ -73,7 +74,7 @@ class ScheduleGenerator:
             )
 
             try:
-                schedule_text, _ = await self.llm_scheduler.generate_response(prompt)
+                schedule_text, _, _ = await self.llm_scheduler.generate_response(prompt)
                 db.schedule.insert_one({"date": date_str, "schedule": schedule_text})
                 self.enable_output = True
             except Exception as e:
@@ -165,24 +166,5 @@ class ScheduleGenerator:
                 logger.info(f"时间[{time_str}]: 活动[{activity}]")
             logger.info("==================")
             self.enable_output = False
-
+# 当作为组件导入时使用的实例
-
-# def main():
-#     # 使用示例
-#     scheduler = ScheduleGenerator()
-#     # new_schedule = scheduler.generate_daily_schedule()
-#     scheduler.print_schedule()
-#     print("\n当前任务：")
-#     print(scheduler.get_current_task())
-
-#     print("昨天日程：")
-#     print(scheduler.yesterday_schedule)
-#     print("今天日程：")
-#     print(scheduler.today_schedule)
-#     print("明天日程：")
-#     print(scheduler.tomorrow_schedule)
-
-# if __name__ == "__main__":
-#     main()
-
 bot_schedule = ScheduleGenerator()

template.env

@@ -1,8 +1,6 @@
 HOST=127.0.0.1
 PORT=8080
 
-ENABLE_ADVANCE_OUTPUT=false
-
 # 插件配置
 PLUGINS=["src2.plugins.chat"]
 
@@ -31,6 +29,7 @@ CHAT_ANY_WHERE_KEY=
 SILICONFLOW_KEY=
 
 # 定义日志相关配置
+SIMPLE_OUTPUT=true # 精简控制台输出格式
 CONSOLE_LOG_LEVEL=INFO # 自定义日志的默认控制台输出日志级别
 FILE_LOG_LEVEL=DEBUG # 自定义日志的默认文件输出日志级别
 DEFAULT_CONSOLE_LOG_LEVEL=SUCCESS # 原生日志的控制台输出日志级别（nonebot就是这一类）

template/bot_config_template.toml

@@ -1,5 +1,5 @@
 [inner]
-version = "0.0.10"
+version = "0.0.11"
 
 #以下是给开发人员阅读的，一般用户不需要阅读
 #如果你想要修改配置文件，请在修改后将version的值进行变更
@@ -66,12 +66,15 @@ model_r1_distill_probability = 0.1 # 麦麦回答时选择次要回复模型3
 max_response_length = 1024 # 麦麦回答的最大token数
 
 [willing]
-willing_mode = "classical"
+willing_mode = "classical" # 回复意愿模式 经典模式
-# willing_mode = "dynamic"
+# willing_mode = "dynamic" # 动态模式(可能不兼容)
-# willing_mode = "custom"
+# willing_mode = "custom" # 自定义模式（可自行调整
 
 [memory]
 build_memory_interval = 2000 # 记忆构建间隔 单位秒   间隔越低，麦麦学习越多，但是冗余信息也会增多
+build_memory_distribution = [4,2,0.6,24,8,0.4] # 记忆构建分布，参数：分布1均值，标准差，权重，分布2均值，标准差，权重
+build_memory_sample_num = 10 # 采样数量，数值越高记忆采样次数越多
+build_memory_sample_length = 20 # 采样长度，数值越高一段记忆内容越丰富
 memory_compress_rate = 0.1 # 记忆压缩率 控制记忆精简程度 建议保持默认,调高可以获得更多信息，但是冗余信息也会增多
 
 forget_memory_interval = 1000 # 记忆遗忘间隔 单位秒   间隔越低，麦麦遗忘越频繁，记忆更精简，但更难学习
@@ -109,9 +112,7 @@ tone_error_rate=0.2 # 声调错误概率
 word_replace_rate=0.006 # 整词替换概率
 
 [others]
-enable_advance_output = false # 是否启用高级输出
 enable_kuuki_read = true # 是否启用读空气功能
-enable_debug_output = false # 是否启用调试输出
 enable_friend_chat = false # 是否启用好友聊天
 
 [groups]
@@ -120,59 +121,67 @@ talk_allowed = [
     123,
 ]  #可以回复消息的群
 talk_frequency_down = []  #降低回复频率的群
-ban_user_id = []  #禁止回复消息的QQ号
+ban_user_id = []  #禁止回复和读取消息的QQ号
 
-[remote] #测试功能，发送统计信息，主要是看全球有多少只麦麦
+[remote] #发送统计信息，主要是看全球有多少只麦麦
 enable = true
 
 
 #下面的模型若使用硅基流动则不需要更改，使用ds官方则改成.env.prod自定义的宏，使用自定义模型则选择定位相似的模型自己填写
-#推理模型：
+#推理模型
+
 [model.llm_reasoning] #回复模型1 主要回复模型
 name = "Pro/deepseek-ai/DeepSeek-R1"
+# name = "Qwen/QwQ-32B"
 provider = "SILICONFLOW"
-pri_in = 0 #模型的输入价格（非必填，可以记录消耗）
+pri_in = 4 #模型的输入价格（非必填，可以记录消耗）
-pri_out = 0 #模型的输出价格（非必填，可以记录消耗）
+pri_out = 16 #模型的输出价格（非必填，可以记录消耗）
 
 [model.llm_reasoning_minor] #回复模型3 次要回复模型
 name = "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
 provider = "SILICONFLOW"
+pri_in = 1.26 #模型的输入价格（非必填，可以记录消耗）
+pri_out = 1.26 #模型的输出价格（非必填，可以记录消耗）
 
 #非推理模型
 
 [model.llm_normal] #V3 回复模型2 次要回复模型
 name = "Pro/deepseek-ai/DeepSeek-V3"
 provider = "SILICONFLOW"
+pri_in = 2 #模型的输入价格（非必填，可以记录消耗）
+pri_out = 8 #模型的输出价格（非必填，可以记录消耗）
 
-[model.llm_normal_minor] #V2.5
+[model.llm_emotion_judge] #表情包判断 
-name = "deepseek-ai/DeepSeek-V2.5"
-provider = "SILICONFLOW"
-
-[model.llm_emotion_judge] #主题判断 0.7/m
 name = "Qwen/Qwen2.5-14B-Instruct"
 provider = "SILICONFLOW"
+pri_in = 0.7
+pri_out = 0.7
 
-[model.llm_topic_judge] #主题判断：建议使用qwen2.5 7b
+[model.llm_topic_judge] #记忆主题判断：建议使用qwen2.5 7b
 name = "Pro/Qwen/Qwen2.5-7B-Instruct"
 provider = "SILICONFLOW"
+pri_in = 0
+pri_out = 0
 
-[model.llm_summary_by_topic] #建议使用qwen2.5 32b 及以上
+[model.llm_summary_by_topic] #概括模型，建议使用qwen2.5 32b 及以上
 name = "Qwen/Qwen2.5-32B-Instruct"
 provider = "SILICONFLOW"
-pri_in = 0
+pri_in = 1.26
-pri_out = 0
+pri_out = 1.26
 
-[model.moderation] #内容审核 未启用
+[model.moderation] #内容审核，开发中
 name = ""
 provider = "SILICONFLOW"
-pri_in = 0
+pri_in = 1.0
-pri_out = 0
+pri_out = 2.0
 
 # 识图模型
 
-[model.vlm] #图像识别 0.35/m
+[model.vlm] #图像识别 
-name = "Pro/Qwen/Qwen2-VL-7B-Instruct"
+name = "Pro/Qwen/Qwen2.5-VL-7B-Instruct"
 provider = "SILICONFLOW"
+pri_in = 0.35
+pri_out = 0.35
 
 #嵌入模型
 

webui.py

@@ -4,11 +4,14 @@ import toml
 import signal
 import sys
 import requests
+
 try:
     from src.common.logger import get_module_logger
+
     logger = get_module_logger("webui")
 except ImportError:
     from loguru import logger
+
     # 检查并创建日志目录
     log_dir = "logs/webui"
     if not os.path.exists(log_dir):
@@ -24,11 +27,13 @@ import ast
 from packaging import version
 from decimal import Decimal
 
+
 def signal_handler(signum, frame):
     """处理 Ctrl+C 信号"""
     logger.info("收到终止信号，正在关闭 Gradio 服务器...")
     sys.exit(0)
 
+
 # 注册信号处理器
 signal.signal(signal.SIGINT, signal_handler)
 
@@ -44,10 +49,10 @@ if not os.path.exists(".env.prod"):
     raise FileNotFoundError("环境配置文件 .env.prod 不存在，请检查配置文件路径")
 
 config_data = toml.load("config/bot_config.toml")
-#增加对老版本配置文件支持
+# 增加对老版本配置文件支持
 LEGACY_CONFIG_VERSION = version.parse("0.0.1")
 
-#增加最低支持版本
+# 增加最低支持版本
 MIN_SUPPORT_VERSION = version.parse("0.0.8")
 MIN_SUPPORT_MAIMAI_VERSION = version.parse("0.5.13")
 
@@ -66,9 +71,18 @@ else:
 
 HAVE_ONLINE_STATUS_VERSION = version.parse("0.0.9")
 
-#添加WebUI配置文件版本
+# 定义意愿模式可选项
+WILLING_MODE_CHOICES = [
+    "classical",
+    "dynamic",
+    "custom",
+]
+
+
+# 添加WebUI配置文件版本
 WEBUI_VERSION = version.parse("0.0.9")
 
+
 # ==============================================
 # env环境配置文件读取部分
 def parse_env_config(config_file):
@@ -84,10 +98,14 @@ def parse_env_config(config_file):
     # 逐行处理配置
     for line in lines:
         line = line.strip()
-        # 忽略空行和注释
+        # 忽略空行和注释行
         if not line or line.startswith("#"):
             continue
 
+        # 处理行尾注释
+        if "#" in line:
+            line = line.split("#")[0].strip()
+
         # 拆分键值对
         key, value = line.split("=", 1)
 
@@ -194,7 +212,7 @@ MODEL_PROVIDER_LIST = parse_model_providers(env_config_data)
 # env读取保存结束
 # ==============================================
 
-#获取在线麦麦数量
+# 获取在线麦麦数量
 
 
 def get_online_maimbot(url="http://hyybuth.xyz:10058/api/clients/details", timeout=10):
@@ -522,6 +540,7 @@ def save_message_and_emoji_config(
 
 
 def save_response_model_config(
+    t_willing_mode,
     t_model_r1_probability,
     t_model_r2_probability,
     t_model_r3_probability,
@@ -543,6 +562,8 @@ def save_response_model_config(
     t_vlm_model_name,
     t_vlm_model_provider,
 ):
+    if PARSED_CONFIG_VERSION >= version.parse("0.0.10"):
+        config_data["willing"]["willing_mode"] = t_willing_mode
     config_data["response"]["model_r1_probability"] = t_model_r1_probability
     config_data["response"]["model_v3_probability"] = t_model_r2_probability
     config_data["response"]["model_r1_distill_probability"] = t_model_r3_probability
@@ -1182,6 +1203,23 @@ with gr.Blocks(title="MaimBot配置文件编辑") as app:
                 with gr.Column(scale=3):
                     with gr.Row():
                         gr.Markdown("""### 回复设置""")
+                    if PARSED_CONFIG_VERSION >= version.parse("0.0.10"):
+                        with gr.Row():
+                            gr.Markdown("""#### 回复意愿模式""")
+                        with gr.Row():
+                            gr.Markdown("""回复意愿模式说明：\n
+                                        classical为经典回复意愿管理器\n
+                                        dynamic为动态意愿管理器\n
+                                        custom为自定义意愿管理器
+                                        """)
+                        with gr.Row():
+                            willing_mode = gr.Dropdown(
+                                choices=WILLING_MODE_CHOICES,
+                                value=config_data["willing"]["willing_mode"],
+                                label="回复意愿模式",
+                            )
+                    else:
+                        willing_mode = gr.Textbox(visible=False, value="disabled")
                     with gr.Row():
                         model_r1_probability = gr.Slider(
                             minimum=0,
@@ -1355,6 +1393,7 @@ with gr.Blocks(title="MaimBot配置文件编辑") as app:
                         save_model_btn.click(
                             save_response_model_config,
                             inputs=[
+                                willing_mode,
                                 model_r1_probability,
                                 model_r2_probability,
                                 model_r3_probability,