Merge branch 'main-fix' into relationship

.gitignore

@@ -16,6 +16,7 @@ memory_graph.gml
 .env.*
 config/bot_config_dev.toml
 config/bot_config.toml
+src/plugins/remote/client_uuid.json
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

run-WebUI.bat

@@ -0,0 +1,4 @@
+CHCP 65001
+@echo off
+python webui.py
+pause

src/plugins/chat/__init__.py

@@ -15,7 +15,7 @@ from .bot import chat_bot
 from .config import global_config
 from .emoji_manager import emoji_manager
 from .relationship_manager import relationship_manager
-from .willing_manager import willing_manager
+from ..willing.willing_manager import willing_manager
 from .chat_stream import chat_manager
 from ..memory_system.memory import hippocampus, memory_graph
 from .bot import ChatBot

src/plugins/chat/bot.py

@@ -29,7 +29,7 @@ from .storage import MessageStorage
 from .utils import calculate_typing_time, is_mentioned_bot_in_message
 from .utils_image import image_path_to_base64
 from .utils_user import get_user_nickname, get_user_cardname, get_groupname
-from .willing_manager import willing_manager  # 导入意愿管理器
+from ..willing.willing_manager import willing_manager  # 导入意愿管理器
 from .message_base import UserInfo, GroupInfo, Seg
 from ..utils.logger_config import LogClassification, LogModule
 
@@ -113,6 +113,8 @@ class ChatBot:
             logger.debug(f"跳过处理回复来自被ban用户 {event.reply.sender.user_id} 的消息")
             return
         # 处理私聊消息
+        
+        
         if isinstance(event, PrivateMessageEvent):
             if not global_config.enable_friend_chat:  # 私聊过滤
                 return
@@ -161,6 +163,7 @@ class ChatBot:
         )
         await message_cq.initialize()
         message_json = message_cq.to_dict()
+        # 哦我嘞个json
 
         # 进入maimbot
         message = MessageRecv(message_json)
@@ -170,8 +173,9 @@ class ChatBot:
 
         # 消息过滤，涉及到config有待更新
 
+        # 创建聊天流
         chat = await chat_manager.get_or_create_stream(
-            platform=messageinfo.platform, user_info=userinfo, group_info=groupinfo
+            platform=messageinfo.platform, user_info=userinfo, group_info=groupinfo #我嘞个gourp_info
         )
         message.update_chat_stream(chat)
         await relationship_manager.update_relationship(
@@ -180,6 +184,7 @@ class ChatBot:
         await relationship_manager.update_relationship_value(chat_stream=chat, relationship_value=0.5)
 
         await message.process()
+        
         # 过滤词
         for word in global_config.ban_words:
             if word in message.processed_plain_text:
@@ -200,8 +205,7 @@ class ChatBot:
 
         current_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(messageinfo.time))
 
-        # topic=await topic_identifier.identify_topic_llm(message.processed_plain_text)
+        #根据话题计算激活度
-
         topic = ""
         interested_rate = await hippocampus.memory_activate_value(message.processed_plain_text) / 100
         logger.debug(f"对{message.processed_plain_text}的激活度:{interested_rate}")

src/plugins/chat/config.py

@@ -73,6 +73,8 @@ class BotConfig:
     mood_update_interval: float = 1.0  # 情绪更新间隔 单位秒
     mood_decay_rate: float = 0.95  # 情绪衰减率
     mood_intensity_factor: float = 0.7  # 情绪强度因子
+    
+    willing_mode: str = "classical"  # 意愿模式
 
     keywords_reaction_rules = []  # 关键词回复规则
 
@@ -212,6 +214,10 @@ class BotConfig:
                 "model_r1_distill_probability", config.MODEL_R1_DISTILL_PROBABILITY
             )
             config.max_response_length = response_config.get("max_response_length", config.max_response_length)
+            
+        def willing(parent: dict):
+            willing_config = parent["willing"]
+            config.willing_mode = willing_config.get("willing_mode", config.willing_mode)
 
         def model(parent: dict):
             # 加载模型配置
@@ -353,6 +359,7 @@ class BotConfig:
             "cq_code": {"func": cq_code, "support": ">=0.0.0"},
             "bot": {"func": bot, "support": ">=0.0.0"},
             "response": {"func": response, "support": ">=0.0.0"},
+            "willing": {"func": willing, "support": ">=0.0.9", "necessary": False},
             "model": {"func": model, "support": ">=0.0.0"},
             "message": {"func": message, "support": ">=0.0.0"},
             "memory": {"func": memory, "support": ">=0.0.0", "necessary": False},

src/plugins/chat/message.py

@@ -160,7 +160,7 @@ class MessageRecv(Message):
         user_info = self.message_info.user_info
         name = (
             f"{user_info.user_nickname}(ta的昵称:{user_info.user_cardname},ta的id:{user_info.user_id})"
-            if user_info.user_cardname != ""
+            if user_info.user_cardname != None
             else f"{user_info.user_nickname}(ta的id:{user_info.user_id})"
         )
         return f"[{time_str}] {name}: {self.processed_plain_text}\n"
@@ -256,7 +256,7 @@ class MessageProcessBase(Message):
         user_info = self.message_info.user_info
         name = (
             f"{user_info.user_nickname}(ta的昵称:{user_info.user_cardname},ta的id:{user_info.user_id})"
-            if user_info.user_cardname != ""
+            if user_info.user_cardname != None
             else f"{user_info.user_nickname}(ta的id:{user_info.user_id})"
         )
         return f"[{time_str}] {name}: {self.processed_plain_text}\n"

src/plugins/chat/prompt_builder.py

@@ -1,7 +1,6 @@
 import random
 import time
 from typing import Optional
-from loguru import logger
 
 from ...common.database import db
 from ..memory_system.memory import hippocampus, memory_graph
@@ -12,6 +11,13 @@ from .utils import get_embedding, get_recent_group_detailed_plain_text, get_rece
 from .chat_stream import chat_manager
 from .relationship_manager import relationship_manager
 
+from ..utils.logger_config import LogClassification, LogModule
+
+log_module = LogModule()
+logger = log_module.setup_logger(LogClassification.PBUILDER)
+
+logger.info("初始化Prompt系统")
+
 
 class PromptBuilder:
     def __init__(self):
@@ -188,7 +194,11 @@ class PromptBuilder:
             prompt_ger += "你喜欢用文言文"
 
         # 额外信息要求
+<<<<<<< HEAD
         extra_info = f'''但是记得你的回复态度和你的立场，切记你回复的人是{sender_name}，不要输出你的思考过程，只需要输出最终的回复，务必简短一些，尤其注意在没明确提到时不要过多提及自身的背景, 不要直接回复别人发的表情包，记住不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，只需要输出回复内容就好，不要输出其他任何内容'''
+=======
+        extra_info = """但是记得回复平淡一些，简短一些，尤其注意在没明确提到时不要过多提及自身的背景, 不要直接回复别人发的表情包，记住不要输出多余内容(包括前后缀，冒号和引号，括号，表情,@,等)，只需要输出回复内容就好，不要输出其他任何内容"""
+>>>>>>> main-fix
 
         # 合并prompt
         prompt = ""
@@ -265,7 +275,7 @@ class PromptBuilder:
         return prompt_for_check, memory
 
     def _build_initiative_prompt(self, selected_node, prompt_regular, memory):
-        prompt_for_initiative = f"{prompt_regular}你现在想在群里发言，回忆了一下，想到一个话题,是{selected_node['concept']}，关于这个话题的记忆有\n{memory}\n，请在把握群里的聊天内容的基础上，综合群内的氛围，以日常且口语化的口吻，简短且随意一点进行发言，不要说的太有条理，可以有个性。记住不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)"
+        prompt_for_initiative = f"{prompt_regular}你现在想在群里发言，回忆了一下，想到一个话题,是{selected_node['concept']}，关于这个话题的记忆有\n{memory}\n，请在把握群里的聊天内容的基础上，综合群内的氛围，以日常且口语化的口吻，简短且随意一点进行发言，不要说的太有条理，可以有个性。记住不要输出多余内容(包括前后缀，冒号和引号，括号，表情,@等)"
         return prompt_for_initiative
 
     async def get_prompt_info(self, message: str, threshold: float):

src/plugins/chat/thinking_idea.py

@@ -1,14 +0,0 @@
-#Broca's Area
-# 功能：语言产生、语法处理和言语运动控制。
-# 损伤后果：布洛卡失语症（表达困难，但理解保留）。
-
-import time
-
-
-class Thinking_Idea:
-    def __init__(self, message_id: str):
-        self.messages = []  # 消息列表集合
-        self.current_thoughts = []  # 当前思考内容列表
-        self.time = time.time()  # 创建时间
-        self.id = str(int(time.time() * 1000))  # 使用时间戳生成唯一标识ID
-        

src/plugins/models/utils_model.py

@@ -530,6 +530,9 @@ class LLM_request:
             list: embedding向量，如果失败则返回None
         """
 
+        if(len(text) < 1):
+            logger.debug("该消息没有长度，不再发送获取embedding向量的请求")
+            return None
         def embedding_handler(result):
             """处理响应"""
             if "data" in result and len(result["data"]) > 0:

src/plugins/remote/__init__.py

@@ -0,0 +1,5 @@
+import asyncio
+from .remote import main
+
+# 启动心跳线程
+heartbeat_thread = main()

src/plugins/remote/remote.py

@@ -0,0 +1,102 @@
+import requests
+import time
+import uuid
+import platform
+import os
+import json
+import threading
+from loguru import logger
+
+# UUID文件路径
+UUID_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "client_uuid.json")
+
+# 生成或获取客户端唯一ID
+def get_unique_id():
+    # 检查是否已经有保存的UUID
+    if os.path.exists(UUID_FILE):
+        try:
+            with open(UUID_FILE, "r") as f:
+                data = json.load(f)
+                if "client_id" in data:
+                    print("从本地文件读取客户端ID")
+                    return data["client_id"]
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"读取UUID文件出错: {e}，将生成新的UUID")
+
+    # 如果没有保存的UUID或读取出错，则生成新的
+    client_id = generate_unique_id()
+
+    # 保存UUID到文件
+    try:
+        with open(UUID_FILE, "w") as f:
+            json.dump({"client_id": client_id}, f)
+        print("已保存新生成的客户端ID到本地文件")
+    except IOError as e:
+        print(f"保存UUID时出错: {e}")
+
+    return client_id
+
+# 生成客户端唯一ID
+def generate_unique_id():
+    # 结合主机名、系统信息和随机UUID生成唯一ID
+    system_info = platform.system()
+    unique_id = f"{system_info}-{uuid.uuid4()}"
+    return unique_id
+
+def send_heartbeat(server_url, client_id):
+    """向服务器发送心跳"""
+    sys = platform.system()
+    try:
+        headers = {"Client-ID": client_id, "User-Agent": f"HeartbeatClient/{client_id[:8]}"}
+        data = json.dumps({"system": sys})
+        response = requests.post(f"{server_url}/api/clients", headers=headers, data=data)
+
+        if response.status_code == 201:
+            data = response.json()
+            logger.debug(f"心跳发送成功。服务器响应: {data}")
+            return True
+        else:
+            logger.debug(f"心跳发送失败。状态码: {response.status_code}")
+            return False
+
+    except requests.RequestException as e:
+        logger.debug(f"发送心跳时出错: {e}")
+        return False
+
+class HeartbeatThread(threading.Thread):
+    """心跳线程类"""
+    
+    def __init__(self, server_url, interval):
+        super().__init__(daemon=True)  # 设置为守护线程，主程序结束时自动结束
+        self.server_url = server_url
+        self.interval = interval
+        self.client_id = get_unique_id()
+        self.running = True
+        
+    def run(self):
+        """线程运行函数"""
+        logger.debug(f"心跳线程已启动，客户端ID: {self.client_id}")
+        
+        while self.running:
+            if send_heartbeat(self.server_url, self.client_id):
+                logger.info(f"{self.interval}秒后发送下一次心跳...")
+            else:
+                logger.info(f"{self.interval}秒后重试...")
+            
+            time.sleep(self.interval)  # 使用同步的睡眠
+    
+    def stop(self):
+        """停止线程"""
+        self.running = False
+
+def main():
+    """主函数，启动心跳线程"""
+    # 配置
+    SERVER_URL = "http://hyybuth.xyz:10058"
+    HEARTBEAT_INTERVAL = 300  # 5分钟（秒）
+    
+    # 创建并启动心跳线程
+    heartbeat_thread = HeartbeatThread(SERVER_URL, HEARTBEAT_INTERVAL)
+    heartbeat_thread.start()
+    
+    return heartbeat_thread  # 返回线程对象，便于外部控制

src/plugins/utils/logger_config.py

@@ -7,6 +7,7 @@ class LogClassification(Enum):
     MEMORY = "memory"
     EMOJI = "emoji"
     CHAT = "chat"
+    PBUILDER = "promptbuilder"
 
 class LogModule:
     logger = loguru.logger.opt()
@@ -32,6 +33,10 @@ class LogModule:
         
         # 表情包系统日志格式
         emoji_format = "<green>{time:HH:mm}</green> | <level>{level: <8}</level> | <yellow>表情包</yellow> | <cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>"
+        
+        promptbuilder_format = "<green>{time:HH:mm}</green> | <level>{level: <8}</level> | <yellow>Prompt</yellow> | <cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>"
+        
+        
         # 根据日志类型选择日志格式和输出
         if log_type == LogClassification.CHAT:
             self.logger.add(
@@ -39,6 +44,12 @@ class LogModule:
                 format=chat_format,
                 # level="INFO"
             )
+        elif log_type == LogClassification.PBUILDER:
+            self.logger.add(
+                sys.stderr,
+                format=promptbuilder_format,
+                # level="INFO"
+            )
         elif log_type == LogClassification.MEMORY:
             
             # 同时输出到控制台和文件

src/plugins/willing/mode_classical.py

@@ -0,0 +1,102 @@
+import asyncio
+from typing import Dict
+from ..chat.chat_stream import ChatStream
+
+class WillingManager:
+    def __init__(self):
+        self.chat_reply_willing: Dict[str, float] = {}  # 存储每个聊天流的回复意愿
+        self._decay_task = None
+        self._started = False
+        
+    async def _decay_reply_willing(self):
+        """定期衰减回复意愿"""
+        while True:
+            await asyncio.sleep(3)
+            for chat_id in self.chat_reply_willing:
+                # 每分钟衰减10%的回复意愿
+                self.chat_reply_willing[chat_id] = max(0, self.chat_reply_willing[chat_id] * 0.6)
+                
+    def get_willing(self, chat_stream: ChatStream) -> float:
+        """获取指定聊天流的回复意愿"""
+        if chat_stream:
+            return self.chat_reply_willing.get(chat_stream.stream_id, 0)
+        return 0
+    
+    def set_willing(self, chat_id: str, willing: float):
+        """设置指定聊天流的回复意愿"""
+        self.chat_reply_willing[chat_id] = willing
+        
+    async def change_reply_willing_received(self, 
+                                          chat_stream: ChatStream,
+                                          topic: str = None,
+                                          is_mentioned_bot: bool = False,
+                                          config = None,
+                                          is_emoji: bool = False,
+                                          interested_rate: float = 0,
+                                          sender_id: str = None) -> float:
+        """改变指定聊天流的回复意愿并返回回复概率"""
+        chat_id = chat_stream.stream_id
+        current_willing = self.chat_reply_willing.get(chat_id, 0)
+        
+        if topic and current_willing < 1:
+            current_willing += 0.2
+        elif topic:
+            current_willing += 0.05
+            
+        if is_mentioned_bot and current_willing < 1.0:
+            current_willing += 0.9
+        elif is_mentioned_bot:
+            current_willing += 0.05
+        
+        if is_emoji:
+            current_willing *= 0.2
+        
+        self.chat_reply_willing[chat_id] = min(current_willing, 3.0)
+        
+        reply_probability = (current_willing - 0.5) * 2
+
+        # 检查群组权限（如果是群聊）
+        if chat_stream.group_info and config:
+            if chat_stream.group_info.group_id not in config.talk_allowed_groups:
+                current_willing = 0
+                reply_probability = 0
+                
+            if chat_stream.group_info.group_id in config.talk_frequency_down_groups:
+                reply_probability = reply_probability / 3.5
+                
+            if is_mentioned_bot and sender_id == "1026294844":
+                reply_probability = 1
+            
+        return reply_probability
+    
+    def change_reply_willing_sent(self, chat_stream: ChatStream):
+        """发送消息后降低聊天流的回复意愿"""
+        if chat_stream:
+            chat_id = chat_stream.stream_id
+            current_willing = self.chat_reply_willing.get(chat_id, 0)
+            self.chat_reply_willing[chat_id] = max(0, current_willing - 1.8)
+    
+    def change_reply_willing_not_sent(self, chat_stream: ChatStream):
+        """未发送消息后降低聊天流的回复意愿"""
+        if chat_stream:
+            chat_id = chat_stream.stream_id
+            current_willing = self.chat_reply_willing.get(chat_id, 0)
+            self.chat_reply_willing[chat_id] = max(0, current_willing - 0)
+        
+    def change_reply_willing_after_sent(self, chat_stream: ChatStream):
+        """发送消息后提高聊天流的回复意愿"""
+        if chat_stream:
+            chat_id = chat_stream.stream_id
+            current_willing = self.chat_reply_willing.get(chat_id, 0)
+            if current_willing < 1:
+                self.chat_reply_willing[chat_id] = min(1, current_willing + 0.4)
+        
+    async def ensure_started(self):
+        """确保衰减任务已启动"""
+        if not self._started:
+            if self._decay_task is None:
+                self._decay_task = asyncio.create_task(self._decay_reply_willing())
+            self._started = True
+
+# 创建全局实例
+willing_manager = WillingManager() 

src/plugins/willing/mode_custom.py

@@ -0,0 +1,102 @@
+import asyncio
+from typing import Dict
+from ..chat.chat_stream import ChatStream
+
+class WillingManager:
+    def __init__(self):
+        self.chat_reply_willing: Dict[str, float] = {}  # 存储每个聊天流的回复意愿
+        self._decay_task = None
+        self._started = False
+        
+    async def _decay_reply_willing(self):
+        """定期衰减回复意愿"""
+        while True:
+            await asyncio.sleep(3)
+            for chat_id in self.chat_reply_willing:
+                # 每分钟衰减10%的回复意愿
+                self.chat_reply_willing[chat_id] = max(0, self.chat_reply_willing[chat_id] * 0.6)
+                
+    def get_willing(self, chat_stream: ChatStream) -> float:
+        """获取指定聊天流的回复意愿"""
+        if chat_stream:
+            return self.chat_reply_willing.get(chat_stream.stream_id, 0)
+        return 0
+    
+    def set_willing(self, chat_id: str, willing: float):
+        """设置指定聊天流的回复意愿"""
+        self.chat_reply_willing[chat_id] = willing
+        
+    async def change_reply_willing_received(self, 
+                                          chat_stream: ChatStream,
+                                          topic: str = None,
+                                          is_mentioned_bot: bool = False,
+                                          config = None,
+                                          is_emoji: bool = False,
+                                          interested_rate: float = 0,
+                                          sender_id: str = None) -> float:
+        """改变指定聊天流的回复意愿并返回回复概率"""
+        chat_id = chat_stream.stream_id
+        current_willing = self.chat_reply_willing.get(chat_id, 0)
+        
+        if topic and current_willing < 1:
+            current_willing += 0.2
+        elif topic:
+            current_willing += 0.05
+            
+        if is_mentioned_bot and current_willing < 1.0:
+            current_willing += 0.9
+        elif is_mentioned_bot:
+            current_willing += 0.05
+        
+        if is_emoji:
+            current_willing *= 0.2
+        
+        self.chat_reply_willing[chat_id] = min(current_willing, 3.0)
+        
+        reply_probability = (current_willing - 0.5) * 2
+
+        # 检查群组权限（如果是群聊）
+        if chat_stream.group_info and config:
+            if chat_stream.group_info.group_id not in config.talk_allowed_groups:
+                current_willing = 0
+                reply_probability = 0
+                
+            if chat_stream.group_info.group_id in config.talk_frequency_down_groups:
+                reply_probability = reply_probability / 3.5
+                
+            if is_mentioned_bot and sender_id == "1026294844":
+                reply_probability = 1
+            
+        return reply_probability
+    
+    def change_reply_willing_sent(self, chat_stream: ChatStream):
+        """发送消息后降低聊天流的回复意愿"""
+        if chat_stream:
+            chat_id = chat_stream.stream_id
+            current_willing = self.chat_reply_willing.get(chat_id, 0)
+            self.chat_reply_willing[chat_id] = max(0, current_willing - 1.8)
+    
+    def change_reply_willing_not_sent(self, chat_stream: ChatStream):
+        """未发送消息后降低聊天流的回复意愿"""
+        if chat_stream:
+            chat_id = chat_stream.stream_id
+            current_willing = self.chat_reply_willing.get(chat_id, 0)
+            self.chat_reply_willing[chat_id] = max(0, current_willing - 0)
+        
+    def change_reply_willing_after_sent(self, chat_stream: ChatStream):
+        """发送消息后提高聊天流的回复意愿"""
+        if chat_stream:
+            chat_id = chat_stream.stream_id
+            current_willing = self.chat_reply_willing.get(chat_id, 0)
+            if current_willing < 1:
+                self.chat_reply_willing[chat_id] = min(1, current_willing + 0.4)
+        
+    async def ensure_started(self):
+        """确保衰减任务已启动"""
+        if not self._started:
+            if self._decay_task is None:
+                self._decay_task = asyncio.create_task(self._decay_reply_willing())
+            self._started = True
+
+# 创建全局实例
+willing_manager = WillingManager() 

src/plugins/willing/mode_dynamic.py

@@ -5,9 +5,8 @@ from typing import Dict
 from loguru import logger
 
 
-from .config import global_config
+from ..chat.config import global_config
-from .chat_stream import ChatStream
+from ..chat.chat_stream import ChatStream
-
 
 class WillingManager:
     def __init__(self):

src/plugins/willing/willing_manager.py

@@ -0,0 +1,32 @@
+from typing import Optional
+from loguru import logger
+
+from ..chat.config import global_config
+from .mode_classical import WillingManager as ClassicalWillingManager
+from .mode_dynamic import WillingManager as DynamicWillingManager
+from .mode_custom import WillingManager as CustomWillingManager
+
+def init_willing_manager() -> Optional[object]:
+    """
+    根据配置初始化并返回对应的WillingManager实例
+    
+    Returns:
+        对应mode的WillingManager实例
+    """
+    mode = global_config.willing_mode.lower()
+    
+    if mode == "classical":
+        logger.info("使用经典回复意愿管理器")
+        return ClassicalWillingManager()
+    elif mode == "dynamic":
+        logger.info("使用动态回复意愿管理器") 
+        return DynamicWillingManager()
+    elif mode == "custom":
+        logger.warning(f"自定义的回复意愿管理器模式: {mode}")
+        return CustomWillingManager()
+    else:
+        logger.warning(f"未知的回复意愿管理器模式: {mode}, 将使用经典模式")
+        return ClassicalWillingManager()
+
+# 全局willing_manager对象
+willing_manager = init_willing_manager()

template/bot_config_template.toml

@@ -1,6 +1,7 @@
 [inner]
-version = "0.0.8"
+version = "0.0.9"
 
+#以下是给开发人员阅读的，一般用户不需要阅读
 #如果你想要修改配置文件，请在修改后将version的值进行变更
 #如果新增项目，请在BotConfig类下新增相应的变量
 #1.如果你修改的是[]层级项目，例如你新增了 [memory],那么请在config.py的 load_config函数中的include_configs字典中新增"内容":{
@@ -64,11 +65,16 @@ model_v3_probability = 0.1 # 麦麦回答时选择次要回复模型2 模型的
 model_r1_distill_probability = 0.1 # 麦麦回答时选择次要回复模型3 模型的概率
 max_response_length = 1024 # 麦麦回答的最大token数
 
+[willing]
+willing_mode = "classical"
+# willing_mode = "dynamic"
+# willing_mode = "custom"
+
 [memory]
-build_memory_interval = 600 # 记忆构建间隔 单位秒   间隔越低，麦麦学习越多，但是冗余信息也会增多
+build_memory_interval = 2000 # 记忆构建间隔 单位秒   间隔越低，麦麦学习越多，但是冗余信息也会增多
 memory_compress_rate = 0.1 # 记忆压缩率 控制记忆精简程度 建议保持默认,调高可以获得更多信息，但是冗余信息也会增多
 
-forget_memory_interval = 600 # 记忆遗忘间隔 单位秒   间隔越低，麦麦遗忘越频繁，记忆更精简，但更难学习
+forget_memory_interval = 1000 # 记忆遗忘间隔 单位秒   间隔越低，麦麦遗忘越频繁，记忆更精简，但更难学习
 memory_forget_time = 24 #多长时间后的记忆会被遗忘 单位小时 
 memory_forget_percentage = 0.01 # 记忆遗忘比例 控制记忆遗忘程度 越大遗忘越多 建议保持默认
 
@@ -116,6 +122,9 @@ talk_allowed = [
 talk_frequency_down = []  #降低回复频率的群
 ban_user_id = []  #禁止回复消息的QQ号
 
+[remote] #测试功能，发送统计信息，主要是看全球有多少只麦麦
+enable = false #默认关闭
+
 
 #V3
 #name = "deepseek-chat"
@@ -178,8 +187,6 @@ pri_out = 0
 name = "Pro/Qwen/Qwen2-VL-7B-Instruct"
 provider = "SILICONFLOW"
 
-
-
 #嵌入模型
 
 [model.embedding] #嵌入