better：优化心流

src/heart_flow/observation.py

@@ -147,8 +147,8 @@ class ChattingObservation(Observation):
         except Exception as e:
             print(f"获取总结失败: {e}")
             self.observe_info = ""
-        print(f"prompt：{prompt}")
+        # print(f"prompt：{prompt}")
-        print(f"self.observe_info：{self.observe_info}")
+        # print(f"self.observe_info：{self.observe_info}")
 
     def translate_message_list_to_str(self):
         self.talking_message_str = ""

src/heart_flow/sub_heartflow.py

@@ -45,7 +45,7 @@ class SubHeartflow:
         self.past_mind = []
         self.current_state: CurrentState = CurrentState()
         self.llm_model = LLM_request(
-            model=global_config.llm_sub_heartflow, temperature=0.3, max_tokens=600, request_type="sub_heart_flow"
+            model=global_config.llm_sub_heartflow, temperature=0.2, max_tokens=600, request_type="sub_heart_flow"
         )
 
         self.main_heartflow_info = ""
@@ -185,19 +185,20 @@ class SubHeartflow:
         # prompt += f"麦麦的总体想法是：{self.main_heartflow_info}\n\n"
         prompt += f"{relation_prompt_all}\n"
         prompt += f"{prompt_personality}\n"
-        prompt += f"你刚刚在做的事情是：{schedule_info}\n"
+        # prompt += f"你刚刚在做的事情是：{schedule_info}\n"
-        if related_memory_info:
+        # if related_memory_info:
-            prompt += f"你想起来你之前见过的回忆：{related_memory_info}。\n以上是你的回忆，不一定是目前聊天里的人说的，也不一定是现在发生的事情，请记住。\n"
+            # prompt += f"你想起来你之前见过的回忆：{related_memory_info}。\n以上是你的回忆，不一定是目前聊天里的人说的，也不一定是现在发生的事情，请记住。\n"
-        if related_info:
+        # if related_info:
-            prompt += f"你想起你知道：{related_info}\n"
+            # prompt += f"你想起你知道：{related_info}\n"
-        prompt += f"刚刚你的想法是{current_thinking_info}。\n"
+        prompt += f"刚刚你的想法是{current_thinking_info}。如果有新的内容，记得转换话题\n"
         prompt += "-----------------------------------\n"
         prompt += f"现在你正在上网，和qq群里的网友们聊天，群里正在聊的话题是：{chat_observe_info}\n"
         prompt += f"你现在{mood_info}\n"
         prompt += f"你注意到{sender_name}刚刚说：{message_txt}\n"
-        prompt += "现在你接下去继续浅浅思考，产生新的想法，不要分点输出，输出连贯的内心独白，不要太长，"
+        prompt += "现在你接下去继续思考，产生新的想法，不要分点输出，输出连贯的内心独白，不要太长，"
-        prompt += "思考时可以想想如何对群聊内容进行回复。请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，"
+        prompt += "思考时可以想想如何对群聊内容进行回复。回复的要求是：平淡一些，简短一些，说中文，不要刻意突出自身学科背景，尽量不要说你说过的话 ，注意只输出回复内容。"
-        prompt += f"记得结合上述的消息，要记得维持住你的人设，注意你就是{self.bot_name}，{self.bot_name}指的就是你。"
+        prompt += "请注意不要输出多余内容(包括前后缀，冒号和引号，括号，表情等)，"
+        prompt += f"记得结合上述的消息，生成符合内心想法的内心独白，文字不要浮夸，注意你就是{self.bot_name}，{self.bot_name}指的就是你。"
 
         try:
             response, reasoning_content = await self.llm_model.generate_response_async(prompt)
@@ -208,7 +209,7 @@ class SubHeartflow:
 
         self.current_mind = response
 
-        logger.debug(f"prompt:\n{prompt}\n")
+        logger.info(f"prompt:\n{prompt}\n")
         logger.info(f"麦麦的思考前脑内状态：{self.current_mind}")
         return self.current_mind ,self.past_mind
 

src/plugins/chat_module/think_flow_chat/think_flow_generator.py

@@ -1,5 +1,6 @@
 import time
 from typing import List, Optional
+import random
 
 
 from ...models.utils_model import LLM_request
@@ -25,7 +26,7 @@ logger = get_module_logger("llm_generator", config=llm_config)
 class ResponseGenerator:
     def __init__(self):
         self.model_normal = LLM_request(
-            model=global_config.llm_normal, temperature=0.6, max_tokens=256, request_type="response_heartflow"
+            model=global_config.llm_normal, temperature=0.3, max_tokens=256, request_type="response_heartflow"
         )
 
         self.model_sum = LLM_request(
@@ -44,23 +45,42 @@ class ResponseGenerator:
         
         arousal_multiplier = MoodManager.get_instance().get_arousal_multiplier()
         
+        time1 = time.time()
         
-        current_model = self.model_normal
+        checked = False
-        current_model.temperature = 0.7 * arousal_multiplier #激活度越高，温度越高
+        if random.random() > 0:
-        model_response = await self._generate_response_with_model(message, current_model,thinking_id)
+            checked = False
+            current_model = self.model_normal
+            current_model.temperature = 0.3 * arousal_multiplier #激活度越高，温度越高
+            model_response = await self._generate_response_with_model(message, current_model,thinking_id,mode="normal")
+            
+            model_checked_response = model_response
+        else:
+            checked = True
+            current_model = self.model_normal
+            current_model.temperature = 0.3 * arousal_multiplier #激活度越高，温度越高
+            print(f"生成{message.processed_plain_text}回复温度是：{current_model.temperature}")
+            model_response = await self._generate_response_with_model(message, current_model,thinking_id,mode="simple")
+            
+            current_model.temperature = 0.3
+            model_checked_response = await self._check_response_with_model(message, model_response, current_model,thinking_id)
 
-        # print(f"raw_content: {model_response}")
+        time2 = time.time()
 
         if model_response:
-            logger.info(f"{global_config.BOT_NICKNAME}的回复是：{model_response}")
+            if checked:
-            model_response = await self._process_response(model_response)
+                logger.info(f"{global_config.BOT_NICKNAME}的回复是：{model_response}，思忖后，回复是：{model_checked_response},生成回复时间: {time2 - time1}秒")
+            else:
+                logger.info(f"{global_config.BOT_NICKNAME}的回复是：{model_response},生成回复时间: {time2 - time1}秒")
+            
+            model_processed_response = await self._process_response(model_checked_response)
 
-            return model_response
+            return model_processed_response
         else:
             logger.info(f"{self.current_model_type}思考，失败")
             return None
 
-    async def _generate_response_with_model(self, message: MessageRecv, model: LLM_request,thinking_id:str):
+    async def _generate_response_with_model(self, message: MessageRecv, model: LLM_request,thinking_id:str,mode:str = "normal") -> str:
         sender_name = ""
         
         info_catcher = info_catcher_manager.get_info_catcher(thinking_id)
@@ -75,20 +95,28 @@ class ResponseGenerator:
         else:
             sender_name = f"用户({message.chat_stream.user_info.user_id})"
 
-        logger.debug("开始使用生成回复-2")
         # 构建prompt
         timer1 = time.time()
-        prompt = await prompt_builder._build_prompt(
+        if mode == "normal":
-            message.chat_stream,
+            prompt = await prompt_builder._build_prompt(
-            message_txt=message.processed_plain_text,
+                message.chat_stream,
-            sender_name=sender_name,
+                message_txt=message.processed_plain_text,
-            stream_id=message.chat_stream.stream_id,
+                sender_name=sender_name,
-        )
+                stream_id=message.chat_stream.stream_id,
+            )
+        elif mode == "simple":
+            prompt = await prompt_builder._build_prompt_simple(
+                message.chat_stream,
+                message_txt=message.processed_plain_text,
+                sender_name=sender_name,
+                stream_id=message.chat_stream.stream_id,
+            )
         timer2 = time.time()
-        logger.info(f"构建prompt时间: {timer2 - timer1}秒")
+        logger.info(f"构建{mode}prompt时间: {timer2 - timer1}秒")
 
         try:
             content, reasoning_content, self.current_model_name = await model.generate_response(prompt)
+        
             
             info_catcher.catch_after_llm_generated(
                 prompt=prompt,
@@ -100,40 +128,54 @@ class ResponseGenerator:
             logger.exception("生成回复时出错")
             return None
 
-        # 保存到数据库
-        # self._save_to_db(
-        #     message=message,
-        #     sender_name=sender_name,
-        #     prompt=prompt,
-        #     content=content,
-        #     reasoning_content=reasoning_content,
-        #     # reasoning_content_check=reasoning_content_check if global_config.enable_kuuki_read else ""
-        # )
 
         return content
+    
+    async def _check_response_with_model(self, message: MessageRecv, content:str, model: LLM_request,thinking_id:str) -> str:
+        
+        _info_catcher = info_catcher_manager.get_info_catcher(thinking_id)
+        
+        sender_name = ""
+        if message.chat_stream.user_info.user_cardname and message.chat_stream.user_info.user_nickname:
+            sender_name = (
+                f"[({message.chat_stream.user_info.user_id}){message.chat_stream.user_info.user_nickname}]"
+                f"{message.chat_stream.user_info.user_cardname}"
+            )
+        elif message.chat_stream.user_info.user_nickname:
+            sender_name = f"({message.chat_stream.user_info.user_id}){message.chat_stream.user_info.user_nickname}"
+        else:
+            sender_name = f"用户({message.chat_stream.user_info.user_id})"
+            
+            
+        # 构建prompt
+        timer1 = time.time()
+        prompt = await prompt_builder._build_prompt_check_response(
+            message.chat_stream,
+            message_txt=message.processed_plain_text,
+            sender_name=sender_name,
+            stream_id=message.chat_stream.stream_id,
+            content=content
+        )
+        timer2 = time.time()
+        logger.info(f"构建check_prompt: {prompt}")
+        logger.info(f"构建check_prompt时间: {timer2 - timer1}秒")
+
+        try:
+            checked_content, reasoning_content, self.current_model_name = await model.generate_response(prompt)
+        
+            
+            # info_catcher.catch_after_llm_generated(
+            #     prompt=prompt,
+            #     response=content,
+            #     reasoning_content=reasoning_content,
+            #     model_name=self.current_model_name)
+            
+        except Exception:
+            logger.exception("检查回复时出错")
+            return None
 
 
-    # def _save_to_db(
+        return checked_content
-    #     self,
-    #     message: MessageRecv,
-    #     sender_name: str,
-    #     prompt: str,
-    #     content: str,
-    #     reasoning_content: str,
-    # ):
-    #     """保存对话记录到数据库"""
-    #     db.reasoning_logs.insert_one(
-    #         {
-    #             "time": time.time(),
-    #             "chat_id": message.chat_stream.stream_id,
-    #             "user": sender_name,
-    #             "message": message.processed_plain_text,
-    #             "model": self.current_model_name,
-    #             "reasoning": reasoning_content,
-    #             "response": content,
-    #             "prompt": prompt,
-    #         }
-    #     )
 
     async def _get_emotion_tags(self, content: str, processed_plain_text: str):
         """提取情感标签，结合立场和情绪"""

src/plugins/chat_module/think_flow_chat/think_flow_prompt_builder.py

@@ -79,12 +79,105 @@ class PromptBuilder:
 {chat_target}
 {chat_talking_prompt}
 现在"{sender_name}"说的:{message_txt}。引起了你的注意，你想要在群里发言发言或者回复这条消息。\n
-你的网名叫{global_config.BOT_NICKNAME}，有人也叫你{"/".join(global_config.BOT_ALIAS_NAMES)}，{prompt_personality} {prompt_identity}。
+你的网名叫{global_config.BOT_NICKNAME}，{prompt_personality} {prompt_identity}。
 你正在{chat_target_2},现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，
 你刚刚脑子里在想：
 {current_mind_info}
 回复尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要回复的太有条理，可以有个性。{prompt_ger}
 请回复的平淡一些，简短一些，说中文，不要刻意突出自身学科背景，尽量不要说你说过的话 ，注意只输出回复内容。
+{moderation_prompt}。注意：不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。"""
+
+        return prompt
+    
+    async def _build_prompt_simple(
+        self, chat_stream, message_txt: str, sender_name: str = "某人", stream_id: Optional[int] = None
+    ) -> tuple[str, str]:
+        current_mind_info = heartflow.get_subheartflow(stream_id).current_mind
+
+        individuality = Individuality.get_instance()
+        prompt_personality = individuality.get_prompt(type="personality", x_person=2, level=1)
+        prompt_identity = individuality.get_prompt(type="identity", x_person=2, level=1)
+
+
+        # 日程构建
+        # schedule_prompt = f'''你现在正在做的事情是：{bot_schedule.get_current_num_task(num = 1,time_info = False)}'''
+
+        # 获取聊天上下文
+        chat_in_group = True
+        chat_talking_prompt = ""
+        if stream_id:
+            chat_talking_prompt = get_recent_group_detailed_plain_text(
+                stream_id, limit=global_config.MAX_CONTEXT_SIZE, combine=True
+            )
+            chat_stream = chat_manager.get_stream(stream_id)
+            if chat_stream.group_info:
+                chat_talking_prompt = chat_talking_prompt
+            else:
+                chat_in_group = False
+                chat_talking_prompt = chat_talking_prompt
+                # print(f"\033[1;34m[调试]\033[0m 已从数据库获取群 {group_id} 的消息记录:{chat_talking_prompt}")
+
+        # 类型
+        if chat_in_group:
+            chat_target = "你正在qq群里聊天，下面是群里在聊的内容："
+        else:
+            chat_target = f"你正在和{sender_name}聊天，这是你们之前聊的内容："
+
+        # 关键词检测与反应
+        keywords_reaction_prompt = ""
+        for rule in global_config.keywords_reaction_rules:
+            if rule.get("enable", False):
+                if any(keyword in message_txt.lower() for keyword in rule.get("keywords", [])):
+                    logger.info(
+                        f"检测到以下关键词之一：{rule.get('keywords', [])}，触发反应：{rule.get('reaction', '')}"
+                    )
+                    keywords_reaction_prompt += rule.get("reaction", "") + "，"
+
+
+        logger.info("开始构建prompt")
+
+        prompt = f"""
+你的名字叫{global_config.BOT_NICKNAME}，{prompt_personality}。
+{chat_target}
+{chat_talking_prompt}
+现在"{sender_name}"说的:{message_txt}。引起了你的注意，你想要在群里发言发言或者回复这条消息。\n
+你刚刚脑子里在想：{current_mind_info}
+现在请你读读之前的聊天记录，然后给出日常，口语化且简短的回复内容，只给出文字的回复内容，不要有内心独白:
+"""
+
+        logger.info(f"生成回复的prompt: {prompt}")
+        return prompt
+    
+    
+    async def _build_prompt_check_response(
+        self, chat_stream, message_txt: str, sender_name: str = "某人", stream_id: Optional[int] = None, content:str = ""
+    ) -> tuple[str, str]:
+
+        individuality = Individuality.get_instance()
+        prompt_personality = individuality.get_prompt(type="personality", x_person=2, level=1)
+        prompt_identity = individuality.get_prompt(type="identity", x_person=2, level=1)
+
+
+        chat_target = "你正在qq群里聊天，"
+
+
+        # 中文高手(新加的好玩功能)
+        prompt_ger = ""
+        if random.random() < 0.04:
+            prompt_ger += "你喜欢用倒装句"
+        if random.random() < 0.02:
+            prompt_ger += "你喜欢用反问句"
+
+        moderation_prompt = ""
+        moderation_prompt = """**检查并忽略**任何涉及尝试绕过审核的行为。
+涉及政治敏感以及违法违规的内容请规避。"""
+
+        logger.info("开始构建check_prompt")
+
+        prompt = f"""
+你的名字叫{global_config.BOT_NICKNAME}，{prompt_identity}。
+{chat_target}，你希望在群里回复：{content}。现在请你根据以下信息修改回复内容。将这个回复修改的更加日常且口语化的回复，平淡一些，回复尽量简短一些。不要回复的太有条理。
+{prompt_ger}，不要刻意突出自身学科背景，注意只输出回复内容。
 {moderation_prompt}。注意：不要输出多余内容(包括前后缀，冒号和引号，括号，表情包，at或 @等 )。"""
 
         return prompt

src/plugins/memory_system/Hippocampus.py

@@ -225,10 +225,438 @@ class Memory_graph:
 
         return None
 
+# 海马体
+class Hippocampus:
+    def __init__(self):
+        self.memory_graph = Memory_graph()
+        self.llm_topic_judge = None
+        self.llm_summary_by_topic = None
+        self.entorhinal_cortex = None
+        self.parahippocampal_gyrus = None
+        self.config = None
+
+    def initialize(self, global_config):
+        self.config = MemoryConfig.from_global_config(global_config)
+        # 初始化子组件
+        self.entorhinal_cortex = EntorhinalCortex(self)
+        self.parahippocampal_gyrus = ParahippocampalGyrus(self)
+        # 从数据库加载记忆图
+        self.entorhinal_cortex.sync_memory_from_db()
+        self.llm_topic_judge = LLM_request(self.config.llm_topic_judge, request_type="memory")
+        self.llm_summary_by_topic = LLM_request(self.config.llm_summary_by_topic, request_type="memory")
+
+    def get_all_node_names(self) -> list:
+        """获取记忆图中所有节点的名字列表"""
+        return list(self.memory_graph.G.nodes())
+
+    def calculate_node_hash(self, concept, memory_items) -> int:
+        """计算节点的特征值"""
+        if not isinstance(memory_items, list):
+            memory_items = [memory_items] if memory_items else []
+        sorted_items = sorted(memory_items)
+        content = f"{concept}:{'|'.join(sorted_items)}"
+        return hash(content)
+
+    def calculate_edge_hash(self, source, target) -> int:
+        """计算边的特征值"""
+        nodes = sorted([source, target])
+        return hash(f"{nodes[0]}:{nodes[1]}")
+
+    def find_topic_llm(self, text, topic_num):
+        prompt = (
+            f"这是一段文字：{text}。请你从这段话中总结出最多{topic_num}个关键的概念，可以是名词，动词，或者特定人物，帮我列出来，"
+            f"将主题用逗号隔开，并加上<>,例如<主题1>,<主题2>......尽可能精简。只需要列举最多{topic_num}个话题就好，不要有序号，不要告诉我其他内容。"
+            f"如果确定找不出主题或者没有明显主题，返回<none>。"
+        )
+        return prompt
+
+    def topic_what(self, text, topic, time_info):
+        prompt = (
+            f'这是一段文字，{time_info}：{text}。我想让你基于这段文字来概括"{topic}"这个概念，帮我总结成一句自然的话，'
+            f"可以包含时间和人物，以及具体的观点。只输出这句话就好"
+        )
+        return prompt
+
+    def calculate_topic_num(self, text, compress_rate):
+        """计算文本的话题数量"""
+        information_content = calculate_information_content(text)
+        topic_by_length = text.count("\n") * compress_rate
+        topic_by_information_content = max(1, min(5, int((information_content - 3) * 2)))
+        topic_num = int((topic_by_length + topic_by_information_content) / 2)
+        logger.debug(
+            f"topic_by_length: {topic_by_length}, topic_by_information_content: {topic_by_information_content}, "
+            f"topic_num: {topic_num}"
+        )
+        return topic_num
+
+    def get_memory_from_keyword(self, keyword: str, max_depth: int = 2) -> list:
+        """从关键词获取相关记忆。
+
+        Args:
+            keyword (str): 关键词
+            max_depth (int, optional): 记忆检索深度，默认为2。1表示只获取直接相关的记忆，2表示获取间接相关的记忆。
+
+        Returns:
+            list: 记忆列表，每个元素是一个元组 (topic, memory_items, similarity)
+                - topic: str, 记忆主题
+                - memory_items: list, 该主题下的记忆项列表
+                - similarity: float, 与关键词的相似度
+        """
+        if not keyword:
+            return []
+
+        # 获取所有节点
+        all_nodes = list(self.memory_graph.G.nodes())
+        memories = []
+
+        # 计算关键词的词集合
+        keyword_words = set(jieba.cut(keyword))
+
+        # 遍历所有节点，计算相似度
+        for node in all_nodes:
+            node_words = set(jieba.cut(node))
+            all_words = keyword_words | node_words
+            v1 = [1 if word in keyword_words else 0 for word in all_words]
+            v2 = [1 if word in node_words else 0 for word in all_words]
+            similarity = cosine_similarity(v1, v2)
+
+            # 如果相似度超过阈值，获取该节点的记忆
+            if similarity >= 0.3:  # 可以调整这个阈值
+                node_data = self.memory_graph.G.nodes[node]
+                memory_items = node_data.get("memory_items", [])
+                if not isinstance(memory_items, list):
+                    memory_items = [memory_items] if memory_items else []
+
+                memories.append((node, memory_items, similarity))
+
+        # 按相似度降序排序
+        memories.sort(key=lambda x: x[2], reverse=True)
+        return memories
+
+    async def get_memory_from_text(
+        self,
+        text: str,
+        max_memory_num: int = 3,
+        max_memory_length: int = 2,
+        max_depth: int = 3,
+        fast_retrieval: bool = False,
+    ) -> list:
+        """从文本中提取关键词并获取相关记忆。
+
+        Args:
+            text (str): 输入文本
+            num (int, optional): 需要返回的记忆数量。默认为5。
+            max_depth (int, optional): 记忆检索深度。默认为2。
+            fast_retrieval (bool, optional): 是否使用快速检索。默认为False。
+                如果为True，使用jieba分词和TF-IDF提取关键词，速度更快但可能不够准确。
+                如果为False，使用LLM提取关键词，速度较慢但更准确。
+
+        Returns:
+            list: 记忆列表，每个元素是一个元组 (topic, memory_items, similarity)
+                - topic: str, 记忆主题
+                - memory_items: list, 该主题下的记忆项列表
+                - similarity: float, 与文本的相似度
+        """
+        if not text:
+            return []
+
+        if fast_retrieval:
+            # 使用jieba分词提取关键词
+            words = jieba.cut(text)
+            # 过滤掉停用词和单字词
+            keywords = [word for word in words if len(word) > 1]
+            # 去重
+            keywords = list(set(keywords))
+            # 限制关键词数量
+            keywords = keywords[:5]
+        else:
+            # 使用LLM提取关键词
+            topic_num = min(5, max(1, int(len(text) * 0.1)))  # 根据文本长度动态调整关键词数量
+            # logger.info(f"提取关键词数量: {topic_num}")
+            topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(text, topic_num))
+
+            # 提取关键词
+            keywords = re.findall(r"<([^>]+)>", topics_response[0])
+            if not keywords:
+                keywords = []
+            else:
+                keywords = [
+                    keyword.strip()
+                    for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",")
+                    if keyword.strip()
+                ]
+
+        # logger.info(f"提取的关键词: {', '.join(keywords)}")
+
+        # 过滤掉不存在于记忆图中的关键词
+        valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G]
+        if not valid_keywords:
+            logger.info("没有找到有效的关键词节点")
+            return []
+
+        logger.info(f"有效的关键词: {', '.join(valid_keywords)}")
+
+        # 从每个关键词获取记忆
+        all_memories = []
+        activate_map = {}  # 存储每个词的累计激活值
+
+        # 对每个关键词进行扩散式检索
+        for keyword in valid_keywords:
+            logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):")
+            # 初始化激活值
+            activation_values = {keyword: 1.0}
+            # 记录已访问的节点
+            visited_nodes = {keyword}
+            # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度)
+            nodes_to_process = [(keyword, 1.0, 0)]
+
+            while nodes_to_process:
+                current_node, current_activation, current_depth = nodes_to_process.pop(0)
+
+                # 如果激活值小于0或超过最大深度，停止扩散
+                if current_activation <= 0 or current_depth >= max_depth:
+                    continue
+
+                # 获取当前节点的所有邻居
+                neighbors = list(self.memory_graph.G.neighbors(current_node))
+
+                for neighbor in neighbors:
+                    if neighbor in visited_nodes:
+                        continue
+
+                    # 获取连接强度
+                    edge_data = self.memory_graph.G[current_node][neighbor]
+                    strength = edge_data.get("strength", 1)
+
+                    # 计算新的激活值
+                    new_activation = current_activation - (1 / strength)
+
+                    if new_activation > 0:
+                        activation_values[neighbor] = new_activation
+                        visited_nodes.add(neighbor)
+                        nodes_to_process.append((neighbor, new_activation, current_depth + 1))
+                        logger.debug(
+                            f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})"
+                        )  # noqa: E501
+
+            # 更新激活映射
+            for node, activation_value in activation_values.items():
+                if activation_value > 0:
+                    if node in activate_map:
+                        activate_map[node] += activation_value
+                    else:
+                        activate_map[node] = activation_value
+
+        # 输出激活映射
+        # logger.info("激活映射统计:")
+        # for node, total_activation in sorted(activate_map.items(), key=lambda x: x[1], reverse=True):
+        #     logger.info(f"节点 '{node}': 累计激活值 = {total_activation:.2f}")
+
+        # 基于激活值平方的独立概率选择
+        remember_map = {}
+        # logger.info("基于激活值平方的归一化选择:")
+
+        # 计算所有激活值的平方和
+        total_squared_activation = sum(activation**2 for activation in activate_map.values())
+        if total_squared_activation > 0:
+            # 计算归一化的激活值
+            normalized_activations = {
+                node: (activation**2) / total_squared_activation for node, activation in activate_map.items()
+            }
+
+            # 按归一化激活值排序并选择前max_memory_num个
+            sorted_nodes = sorted(normalized_activations.items(), key=lambda x: x[1], reverse=True)[:max_memory_num]
+
+            # 将选中的节点添加到remember_map
+            for node, normalized_activation in sorted_nodes:
+                remember_map[node] = activate_map[node]  # 使用原始激活值
+                logger.debug(
+                    f"节点 '{node}' (归一化激活值: {normalized_activation:.2f}, 激活值: {activate_map[node]:.2f})"
+                )
+        else:
+            logger.info("没有有效的激活值")
+
+        # 从选中的节点中提取记忆
+        all_memories = []
+        # logger.info("开始从选中的节点中提取记忆:")
+        for node, activation in remember_map.items():
+            logger.debug(f"处理节点 '{node}' (激活值: {activation:.2f}):")
+            node_data = self.memory_graph.G.nodes[node]
+            memory_items = node_data.get("memory_items", [])
+            if not isinstance(memory_items, list):
+                memory_items = [memory_items] if memory_items else []
+
+            if memory_items:
+                logger.debug(f"节点包含 {len(memory_items)} 条记忆")
+                # 计算每条记忆与输入文本的相似度
+                memory_similarities = []
+                for memory in memory_items:
+                    # 计算与输入文本的相似度
+                    memory_words = set(jieba.cut(memory))
+                    text_words = set(jieba.cut(text))
+                    all_words = memory_words | text_words
+                    v1 = [1 if word in memory_words else 0 for word in all_words]
+                    v2 = [1 if word in text_words else 0 for word in all_words]
+                    similarity = cosine_similarity(v1, v2)
+                    memory_similarities.append((memory, similarity))
+
+                # 按相似度排序
+                memory_similarities.sort(key=lambda x: x[1], reverse=True)
+                # 获取最匹配的记忆
+                top_memories = memory_similarities[:max_memory_length]
+
+                # 添加到结果中
+                for memory, similarity in top_memories:
+                    all_memories.append((node, [memory], similarity))
+                    # logger.info(f"选中记忆: {memory} (相似度: {similarity:.2f})")
+            else:
+                logger.info("节点没有记忆")
+
+        # 去重（基于记忆内容）
+        logger.debug("开始记忆去重:")
+        seen_memories = set()
+        unique_memories = []
+        for topic, memory_items, activation_value in all_memories:
+            memory = memory_items[0]  # 因为每个topic只有一条记忆
+            if memory not in seen_memories:
+                seen_memories.add(memory)
+                unique_memories.append((topic, memory_items, activation_value))
+                logger.debug(f"保留记忆: {memory} (来自节点: {topic}, 激活值: {activation_value:.2f})")
+            else:
+                logger.debug(f"跳过重复记忆: {memory} (来自节点: {topic})")
+
+        # 转换为(关键词, 记忆)格式
+        result = []
+        for topic, memory_items, _ in unique_memories:
+            memory = memory_items[0]  # 因为每个topic只有一条记忆
+            result.append((topic, memory))
+            logger.info(f"选中记忆: {memory} (来自节点: {topic})")
+
+        return result
+
+    async def get_activate_from_text(self, text: str, max_depth: int = 3, fast_retrieval: bool = False) -> float:
+        """从文本中提取关键词并获取相关记忆。
+
+        Args:
+            text (str): 输入文本
+            num (int, optional): 需要返回的记忆数量。默认为5。
+            max_depth (int, optional): 记忆检索深度。默认为2。
+            fast_retrieval (bool, optional): 是否使用快速检索。默认为False。
+                如果为True，使用jieba分词和TF-IDF提取关键词，速度更快但可能不够准确。
+                如果为False，使用LLM提取关键词，速度较慢但更准确。
+
+        Returns:
+            float: 激活节点数与总节点数的比值
+        """
+        if not text:
+            return 0
+
+        if fast_retrieval:
+            # 使用jieba分词提取关键词
+            words = jieba.cut(text)
+            # 过滤掉停用词和单字词
+            keywords = [word for word in words if len(word) > 1]
+            # 去重
+            keywords = list(set(keywords))
+            # 限制关键词数量
+            keywords = keywords[:5]
+        else:
+            # 使用LLM提取关键词
+            topic_num = min(5, max(1, int(len(text) * 0.1)))  # 根据文本长度动态调整关键词数量
+            # logger.info(f"提取关键词数量: {topic_num}")
+            topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(text, topic_num))
+
+            # 提取关键词
+            keywords = re.findall(r"<([^>]+)>", topics_response[0])
+            if not keywords:
+                keywords = []
+            else:
+                keywords = [
+                    keyword.strip()
+                    for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",")
+                    if keyword.strip()
+                ]
+
+        # logger.info(f"提取的关键词: {', '.join(keywords)}")
+
+        # 过滤掉不存在于记忆图中的关键词
+        valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G]
+        if not valid_keywords:
+            logger.info("没有找到有效的关键词节点")
+            return 0
+
+        logger.info(f"有效的关键词: {', '.join(valid_keywords)}")
+
+        # 从每个关键词获取记忆
+        activate_map = {}  # 存储每个词的累计激活值
+
+        # 对每个关键词进行扩散式检索
+        for keyword in valid_keywords:
+            logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):")
+            # 初始化激活值
+            activation_values = {keyword: 1.0}
+            # 记录已访问的节点
+            visited_nodes = {keyword}
+            # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度)
+            nodes_to_process = [(keyword, 1.0, 0)]
+
+            while nodes_to_process:
+                current_node, current_activation, current_depth = nodes_to_process.pop(0)
+
+                # 如果激活值小于0或超过最大深度，停止扩散
+                if current_activation <= 0 or current_depth >= max_depth:
+                    continue
+
+                # 获取当前节点的所有邻居
+                neighbors = list(self.memory_graph.G.neighbors(current_node))
+
+                for neighbor in neighbors:
+                    if neighbor in visited_nodes:
+                        continue
+
+                    # 获取连接强度
+                    edge_data = self.memory_graph.G[current_node][neighbor]
+                    strength = edge_data.get("strength", 1)
+
+                    # 计算新的激活值
+                    new_activation = current_activation - (1 / strength)
+
+                    if new_activation > 0:
+                        activation_values[neighbor] = new_activation
+                        visited_nodes.add(neighbor)
+                        nodes_to_process.append((neighbor, new_activation, current_depth + 1))
+                        # logger.debug(
+                        # f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})")  # noqa: E501
+
+            # 更新激活映射
+            for node, activation_value in activation_values.items():
+                if activation_value > 0:
+                    if node in activate_map:
+                        activate_map[node] += activation_value
+                    else:
+                        activate_map[node] = activation_value
+
+        # 输出激活映射
+        # logger.info("激活映射统计:")
+        # for node, total_activation in sorted(activate_map.items(), key=lambda x: x[1], reverse=True):
+        #     logger.info(f"节点 '{node}': 累计激活值 = {total_activation:.2f}")
+
+        # 计算激活节点数与总节点数的比值
+        total_activation = sum(activate_map.values())
+        logger.info(f"总激活值: {total_activation:.2f}")
+        total_nodes = len(self.memory_graph.G.nodes())
+        # activated_nodes = len(activate_map)
+        activation_ratio = total_activation / total_nodes if total_nodes > 0 else 0
+        activation_ratio = activation_ratio * 60
+        logger.info(f"总激活值: {total_activation:.2f}, 总节点数: {total_nodes}, 激活: {activation_ratio}")
+
+        return activation_ratio
+
+
 
 # 负责海马体与其他部分的交互
 class EntorhinalCortex:
-    def __init__(self, hippocampus):
+    def __init__(self, hippocampus: Hippocampus):
         self.hippocampus = hippocampus
         self.memory_graph = hippocampus.memory_graph
         self.config = hippocampus.config
@@ -819,433 +1247,6 @@ class ParahippocampalGyrus:
         logger.info(f"[遗忘] 总耗时: {end_time - start_time:.2f}秒")
 
 
-# 海马体
-class Hippocampus:
-    def __init__(self):
-        self.memory_graph = Memory_graph()
-        self.llm_topic_judge = None
-        self.llm_summary_by_topic = None
-        self.entorhinal_cortex = None
-        self.parahippocampal_gyrus = None
-        self.config = None
-
-    def initialize(self, global_config):
-        self.config = MemoryConfig.from_global_config(global_config)
-        # 初始化子组件
-        self.entorhinal_cortex = EntorhinalCortex(self)
-        self.parahippocampal_gyrus = ParahippocampalGyrus(self)
-        # 从数据库加载记忆图
-        self.entorhinal_cortex.sync_memory_from_db()
-        self.llm_topic_judge = LLM_request(self.config.llm_topic_judge, request_type="memory")
-        self.llm_summary_by_topic = LLM_request(self.config.llm_summary_by_topic, request_type="memory")
-
-    def get_all_node_names(self) -> list:
-        """获取记忆图中所有节点的名字列表"""
-        return list(self.memory_graph.G.nodes())
-
-    def calculate_node_hash(self, concept, memory_items) -> int:
-        """计算节点的特征值"""
-        if not isinstance(memory_items, list):
-            memory_items = [memory_items] if memory_items else []
-        sorted_items = sorted(memory_items)
-        content = f"{concept}:{'|'.join(sorted_items)}"
-        return hash(content)
-
-    def calculate_edge_hash(self, source, target) -> int:
-        """计算边的特征值"""
-        nodes = sorted([source, target])
-        return hash(f"{nodes[0]}:{nodes[1]}")
-
-    def find_topic_llm(self, text, topic_num):
-        prompt = (
-            f"这是一段文字：{text}。请你从这段话中总结出最多{topic_num}个关键的概念，可以是名词，动词，或者特定人物，帮我列出来，"
-            f"将主题用逗号隔开，并加上<>,例如<主题1>,<主题2>......尽可能精简。只需要列举最多{topic_num}个话题就好，不要有序号，不要告诉我其他内容。"
-            f"如果确定找不出主题或者没有明显主题，返回<none>。"
-        )
-        return prompt
-
-    def topic_what(self, text, topic, time_info):
-        prompt = (
-            f'这是一段文字，{time_info}：{text}。我想让你基于这段文字来概括"{topic}"这个概念，帮我总结成一句自然的话，'
-            f"可以包含时间和人物，以及具体的观点。只输出这句话就好"
-        )
-        return prompt
-
-    def calculate_topic_num(self, text, compress_rate):
-        """计算文本的话题数量"""
-        information_content = calculate_information_content(text)
-        topic_by_length = text.count("\n") * compress_rate
-        topic_by_information_content = max(1, min(5, int((information_content - 3) * 2)))
-        topic_num = int((topic_by_length + topic_by_information_content) / 2)
-        logger.debug(
-            f"topic_by_length: {topic_by_length}, topic_by_information_content: {topic_by_information_content}, "
-            f"topic_num: {topic_num}"
-        )
-        return topic_num
-
-    def get_memory_from_keyword(self, keyword: str, max_depth: int = 2) -> list:
-        """从关键词获取相关记忆。
-
-        Args:
-            keyword (str): 关键词
-            max_depth (int, optional): 记忆检索深度，默认为2。1表示只获取直接相关的记忆，2表示获取间接相关的记忆。
-
-        Returns:
-            list: 记忆列表，每个元素是一个元组 (topic, memory_items, similarity)
-                - topic: str, 记忆主题
-                - memory_items: list, 该主题下的记忆项列表
-                - similarity: float, 与关键词的相似度
-        """
-        if not keyword:
-            return []
-
-        # 获取所有节点
-        all_nodes = list(self.memory_graph.G.nodes())
-        memories = []
-
-        # 计算关键词的词集合
-        keyword_words = set(jieba.cut(keyword))
-
-        # 遍历所有节点，计算相似度
-        for node in all_nodes:
-            node_words = set(jieba.cut(node))
-            all_words = keyword_words | node_words
-            v1 = [1 if word in keyword_words else 0 for word in all_words]
-            v2 = [1 if word in node_words else 0 for word in all_words]
-            similarity = cosine_similarity(v1, v2)
-
-            # 如果相似度超过阈值，获取该节点的记忆
-            if similarity >= 0.3:  # 可以调整这个阈值
-                node_data = self.memory_graph.G.nodes[node]
-                memory_items = node_data.get("memory_items", [])
-                if not isinstance(memory_items, list):
-                    memory_items = [memory_items] if memory_items else []
-
-                memories.append((node, memory_items, similarity))
-
-        # 按相似度降序排序
-        memories.sort(key=lambda x: x[2], reverse=True)
-        return memories
-
-    async def get_memory_from_text(
-        self,
-        text: str,
-        max_memory_num: int = 3,
-        max_memory_length: int = 2,
-        max_depth: int = 3,
-        fast_retrieval: bool = False,
-    ) -> list:
-        """从文本中提取关键词并获取相关记忆。
-
-        Args:
-            text (str): 输入文本
-            num (int, optional): 需要返回的记忆数量。默认为5。
-            max_depth (int, optional): 记忆检索深度。默认为2。
-            fast_retrieval (bool, optional): 是否使用快速检索。默认为False。
-                如果为True，使用jieba分词和TF-IDF提取关键词，速度更快但可能不够准确。
-                如果为False，使用LLM提取关键词，速度较慢但更准确。
-
-        Returns:
-            list: 记忆列表，每个元素是一个元组 (topic, memory_items, similarity)
-                - topic: str, 记忆主题
-                - memory_items: list, 该主题下的记忆项列表
-                - similarity: float, 与文本的相似度
-        """
-        if not text:
-            return []
-
-        if fast_retrieval:
-            # 使用jieba分词提取关键词
-            words = jieba.cut(text)
-            # 过滤掉停用词和单字词
-            keywords = [word for word in words if len(word) > 1]
-            # 去重
-            keywords = list(set(keywords))
-            # 限制关键词数量
-            keywords = keywords[:5]
-        else:
-            # 使用LLM提取关键词
-            topic_num = min(5, max(1, int(len(text) * 0.1)))  # 根据文本长度动态调整关键词数量
-            # logger.info(f"提取关键词数量: {topic_num}")
-            topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(text, topic_num))
-
-            # 提取关键词
-            keywords = re.findall(r"<([^>]+)>", topics_response[0])
-            if not keywords:
-                keywords = []
-            else:
-                keywords = [
-                    keyword.strip()
-                    for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",")
-                    if keyword.strip()
-                ]
-
-        # logger.info(f"提取的关键词: {', '.join(keywords)}")
-
-        # 过滤掉不存在于记忆图中的关键词
-        valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G]
-        if not valid_keywords:
-            logger.info("没有找到有效的关键词节点")
-            return []
-
-        logger.info(f"有效的关键词: {', '.join(valid_keywords)}")
-
-        # 从每个关键词获取记忆
-        all_memories = []
-        activate_map = {}  # 存储每个词的累计激活值
-
-        # 对每个关键词进行扩散式检索
-        for keyword in valid_keywords:
-            logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):")
-            # 初始化激活值
-            activation_values = {keyword: 1.0}
-            # 记录已访问的节点
-            visited_nodes = {keyword}
-            # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度)
-            nodes_to_process = [(keyword, 1.0, 0)]
-
-            while nodes_to_process:
-                current_node, current_activation, current_depth = nodes_to_process.pop(0)
-
-                # 如果激活值小于0或超过最大深度，停止扩散
-                if current_activation <= 0 or current_depth >= max_depth:
-                    continue
-
-                # 获取当前节点的所有邻居
-                neighbors = list(self.memory_graph.G.neighbors(current_node))
-
-                for neighbor in neighbors:
-                    if neighbor in visited_nodes:
-                        continue
-
-                    # 获取连接强度
-                    edge_data = self.memory_graph.G[current_node][neighbor]
-                    strength = edge_data.get("strength", 1)
-
-                    # 计算新的激活值
-                    new_activation = current_activation - (1 / strength)
-
-                    if new_activation > 0:
-                        activation_values[neighbor] = new_activation
-                        visited_nodes.add(neighbor)
-                        nodes_to_process.append((neighbor, new_activation, current_depth + 1))
-                        logger.debug(
-                            f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})"
-                        )  # noqa: E501
-
-            # 更新激活映射
-            for node, activation_value in activation_values.items():
-                if activation_value > 0:
-                    if node in activate_map:
-                        activate_map[node] += activation_value
-                    else:
-                        activate_map[node] = activation_value
-
-        # 输出激活映射
-        # logger.info("激活映射统计:")
-        # for node, total_activation in sorted(activate_map.items(), key=lambda x: x[1], reverse=True):
-        #     logger.info(f"节点 '{node}': 累计激活值 = {total_activation:.2f}")
-
-        # 基于激活值平方的独立概率选择
-        remember_map = {}
-        # logger.info("基于激活值平方的归一化选择:")
-
-        # 计算所有激活值的平方和
-        total_squared_activation = sum(activation**2 for activation in activate_map.values())
-        if total_squared_activation > 0:
-            # 计算归一化的激活值
-            normalized_activations = {
-                node: (activation**2) / total_squared_activation for node, activation in activate_map.items()
-            }
-
-            # 按归一化激活值排序并选择前max_memory_num个
-            sorted_nodes = sorted(normalized_activations.items(), key=lambda x: x[1], reverse=True)[:max_memory_num]
-
-            # 将选中的节点添加到remember_map
-            for node, normalized_activation in sorted_nodes:
-                remember_map[node] = activate_map[node]  # 使用原始激活值
-                logger.debug(
-                    f"节点 '{node}' (归一化激活值: {normalized_activation:.2f}, 激活值: {activate_map[node]:.2f})"
-                )
-        else:
-            logger.info("没有有效的激活值")
-
-        # 从选中的节点中提取记忆
-        all_memories = []
-        # logger.info("开始从选中的节点中提取记忆:")
-        for node, activation in remember_map.items():
-            logger.debug(f"处理节点 '{node}' (激活值: {activation:.2f}):")
-            node_data = self.memory_graph.G.nodes[node]
-            memory_items = node_data.get("memory_items", [])
-            if not isinstance(memory_items, list):
-                memory_items = [memory_items] if memory_items else []
-
-            if memory_items:
-                logger.debug(f"节点包含 {len(memory_items)} 条记忆")
-                # 计算每条记忆与输入文本的相似度
-                memory_similarities = []
-                for memory in memory_items:
-                    # 计算与输入文本的相似度
-                    memory_words = set(jieba.cut(memory))
-                    text_words = set(jieba.cut(text))
-                    all_words = memory_words | text_words
-                    v1 = [1 if word in memory_words else 0 for word in all_words]
-                    v2 = [1 if word in text_words else 0 for word in all_words]
-                    similarity = cosine_similarity(v1, v2)
-                    memory_similarities.append((memory, similarity))
-
-                # 按相似度排序
-                memory_similarities.sort(key=lambda x: x[1], reverse=True)
-                # 获取最匹配的记忆
-                top_memories = memory_similarities[:max_memory_length]
-
-                # 添加到结果中
-                for memory, similarity in top_memories:
-                    all_memories.append((node, [memory], similarity))
-                    # logger.info(f"选中记忆: {memory} (相似度: {similarity:.2f})")
-            else:
-                logger.info("节点没有记忆")
-
-        # 去重（基于记忆内容）
-        logger.debug("开始记忆去重:")
-        seen_memories = set()
-        unique_memories = []
-        for topic, memory_items, activation_value in all_memories:
-            memory = memory_items[0]  # 因为每个topic只有一条记忆
-            if memory not in seen_memories:
-                seen_memories.add(memory)
-                unique_memories.append((topic, memory_items, activation_value))
-                logger.debug(f"保留记忆: {memory} (来自节点: {topic}, 激活值: {activation_value:.2f})")
-            else:
-                logger.debug(f"跳过重复记忆: {memory} (来自节点: {topic})")
-
-        # 转换为(关键词, 记忆)格式
-        result = []
-        for topic, memory_items, _ in unique_memories:
-            memory = memory_items[0]  # 因为每个topic只有一条记忆
-            result.append((topic, memory))
-            logger.info(f"选中记忆: {memory} (来自节点: {topic})")
-
-        return result
-
-    async def get_activate_from_text(self, text: str, max_depth: int = 3, fast_retrieval: bool = False) -> float:
-        """从文本中提取关键词并获取相关记忆。
-
-        Args:
-            text (str): 输入文本
-            num (int, optional): 需要返回的记忆数量。默认为5。
-            max_depth (int, optional): 记忆检索深度。默认为2。
-            fast_retrieval (bool, optional): 是否使用快速检索。默认为False。
-                如果为True，使用jieba分词和TF-IDF提取关键词，速度更快但可能不够准确。
-                如果为False，使用LLM提取关键词，速度较慢但更准确。
-
-        Returns:
-            float: 激活节点数与总节点数的比值
-        """
-        if not text:
-            return 0
-
-        if fast_retrieval:
-            # 使用jieba分词提取关键词
-            words = jieba.cut(text)
-            # 过滤掉停用词和单字词
-            keywords = [word for word in words if len(word) > 1]
-            # 去重
-            keywords = list(set(keywords))
-            # 限制关键词数量
-            keywords = keywords[:5]
-        else:
-            # 使用LLM提取关键词
-            topic_num = min(5, max(1, int(len(text) * 0.1)))  # 根据文本长度动态调整关键词数量
-            # logger.info(f"提取关键词数量: {topic_num}")
-            topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(text, topic_num))
-
-            # 提取关键词
-            keywords = re.findall(r"<([^>]+)>", topics_response[0])
-            if not keywords:
-                keywords = []
-            else:
-                keywords = [
-                    keyword.strip()
-                    for keyword in ",".join(keywords).replace("，", ",").replace("、", ",").replace(" ", ",").split(",")
-                    if keyword.strip()
-                ]
-
-        # logger.info(f"提取的关键词: {', '.join(keywords)}")
-
-        # 过滤掉不存在于记忆图中的关键词
-        valid_keywords = [keyword for keyword in keywords if keyword in self.memory_graph.G]
-        if not valid_keywords:
-            logger.info("没有找到有效的关键词节点")
-            return 0
-
-        logger.info(f"有效的关键词: {', '.join(valid_keywords)}")
-
-        # 从每个关键词获取记忆
-        activate_map = {}  # 存储每个词的累计激活值
-
-        # 对每个关键词进行扩散式检索
-        for keyword in valid_keywords:
-            logger.debug(f"开始以关键词 '{keyword}' 为中心进行扩散检索 (最大深度: {max_depth}):")
-            # 初始化激活值
-            activation_values = {keyword: 1.0}
-            # 记录已访问的节点
-            visited_nodes = {keyword}
-            # 待处理的节点队列，每个元素是(节点, 激活值, 当前深度)
-            nodes_to_process = [(keyword, 1.0, 0)]
-
-            while nodes_to_process:
-                current_node, current_activation, current_depth = nodes_to_process.pop(0)
-
-                # 如果激活值小于0或超过最大深度，停止扩散
-                if current_activation <= 0 or current_depth >= max_depth:
-                    continue
-
-                # 获取当前节点的所有邻居
-                neighbors = list(self.memory_graph.G.neighbors(current_node))
-
-                for neighbor in neighbors:
-                    if neighbor in visited_nodes:
-                        continue
-
-                    # 获取连接强度
-                    edge_data = self.memory_graph.G[current_node][neighbor]
-                    strength = edge_data.get("strength", 1)
-
-                    # 计算新的激活值
-                    new_activation = current_activation - (1 / strength)
-
-                    if new_activation > 0:
-                        activation_values[neighbor] = new_activation
-                        visited_nodes.add(neighbor)
-                        nodes_to_process.append((neighbor, new_activation, current_depth + 1))
-                        # logger.debug(
-                        # f"节点 '{neighbor}' 被激活，激活值: {new_activation:.2f} (通过 '{current_node}' 连接，强度: {strength}, 深度: {current_depth + 1})")  # noqa: E501
-
-            # 更新激活映射
-            for node, activation_value in activation_values.items():
-                if activation_value > 0:
-                    if node in activate_map:
-                        activate_map[node] += activation_value
-                    else:
-                        activate_map[node] = activation_value
-
-        # 输出激活映射
-        # logger.info("激活映射统计:")
-        # for node, total_activation in sorted(activate_map.items(), key=lambda x: x[1], reverse=True):
-        #     logger.info(f"节点 '{node}': 累计激活值 = {total_activation:.2f}")
-
-        # 计算激活节点数与总节点数的比值
-        total_activation = sum(activate_map.values())
-        logger.info(f"总激活值: {total_activation:.2f}")
-        total_nodes = len(self.memory_graph.G.nodes())
-        # activated_nodes = len(activate_map)
-        activation_ratio = total_activation / total_nodes if total_nodes > 0 else 0
-        activation_ratio = activation_ratio * 60
-        logger.info(f"总激活值: {total_activation:.2f}, 总节点数: {total_nodes}, 激活: {activation_ratio}")
-
-        return activation_ratio
-
 
 class HippocampusManager:
     _instance = None

src/plugins/moods/moods.py

@@ -137,14 +137,14 @@ class MoodManager:
         personality = Individuality.get_instance().personality
         if personality:
             # 神经质：影响情绪变化速度
-            neuroticism_factor = 1 + (personality.neuroticism - 0.5) * 0.5
+            neuroticism_factor = 1 + (personality.neuroticism - 0.5) * 0.4
-            agreeableness_factor = 1 + (personality.agreeableness - 0.5) * 0.5
+            agreeableness_factor = 1 + (personality.agreeableness - 0.5) * 0.4
 
             # 宜人性：影响情绪基准线
             if personality.agreeableness < 0.2:
-                agreeableness_bias = (personality.agreeableness - 0.2) * 2
+                agreeableness_bias = (personality.agreeableness - 0.2) * 0.5
             elif personality.agreeableness > 0.8:
-                agreeableness_bias = (personality.agreeableness - 0.8) * 2
+                agreeableness_bias = (personality.agreeableness - 0.8) * 0.5
             else:
                 agreeableness_bias = 0
 

template/bot_config_template.toml

@@ -75,8 +75,8 @@ model_v3_probability = 0.3 # 麦麦回答时选择次要回复模型2 模型的
 
 [heartflow] # 注意：可能会消耗大量token，请谨慎开启，仅会使用v3模型
 sub_heart_flow_update_interval = 60 # 子心流更新频率，间隔 单位秒
-sub_heart_flow_freeze_time = 120 # 子心流冻结时间，超过这个时间没有回复，子心流会冻结，间隔 单位秒
+sub_heart_flow_freeze_time = 100 # 子心流冻结时间，超过这个时间没有回复，子心流会冻结，间隔 单位秒
-sub_heart_flow_stop_time = 600 # 子心流停止时间，超过这个时间没有回复，子心流会停止，间隔 单位秒
+sub_heart_flow_stop_time = 500 # 子心流停止时间，超过这个时间没有回复，子心流会停止，间隔 单位秒
 heart_flow_update_interval = 300 # 心流更新频率，间隔 单位秒