初始化

src/chat/memory_system/instant_memory.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+import time
+import re
+import json
+import ast
+import traceback
+
+from json_repair import repair_json
+from datetime import datetime, timedelta
+
+from src.llm_models.utils_model import LLMRequest
+from src.common.logger import get_logger
+from src.common.database.sqlalchemy_models import Memory  # SQLAlchemy Models导入
+from src.common.database.sqlalchemy_database_api import get_session
+from src.config.config import model_config
+
+from sqlalchemy import select
+logger = get_logger(__name__)
+session = get_session()
+
+class MemoryItem:
+    def __init__(self, memory_id: str, chat_id: str, memory_text: str, keywords: list[str]):
+        self.memory_id = memory_id
+        self.chat_id = chat_id
+        self.memory_text: str = memory_text
+        self.keywords: list[str] = keywords
+        self.create_time: float = time.time()
+        self.last_view_time: float = time.time()
+
+
+class MemoryManager:
+    def __init__(self):
+        # self.memory_items:list[MemoryItem] = []
+        pass
+
+
+class InstantMemory:
+    def __init__(self, chat_id):
+        self.chat_id = chat_id
+        self.last_view_time = time.time()
+        self.summary_model = LLMRequest(
+            model_set=model_config.model_task_config.utils,
+            request_type="memory.summary",
+        )
+
+    async def if_need_build(self, text):
+        prompt = f"""
+请判断以下内容中是否有值得记忆的信息，如果有，请输出1，否则输出0
+{text}
+请只输出1或0就好
+        """
+
+        try:
+            response, _ = await self.summary_model.generate_response_async(prompt, temperature=0.5)
+            print(prompt)
+            print(response)
+
+            return "1" in response
+        except Exception as e:
+            logger.error(f"判断是否需要记忆出现错误：{str(e)} {traceback.format_exc()}")
+            return False
+
+    async def build_memory(self, text):
+        prompt = f"""
+        以下内容中存在值得记忆的信息，请你从中总结出一段值得记忆的信息，并输出
+        {text}
+        请以json格式输出一段概括的记忆内容和关键词
+        {{
+            "memory_text": "记忆内容",
+            "keywords": "关键词，用/划分"
+        }}
+        """
+        try:
+            response, _ = await self.summary_model.generate_response_async(prompt, temperature=0.5)
+            # print(prompt)
+            # print(response)
+            if not response:
+                return None
+            try:
+                repaired = repair_json(response)
+                result = json.loads(repaired)
+                memory_text = result.get("memory_text", "")
+                keywords = result.get("keywords", "")
+                if isinstance(keywords, str):
+                    keywords_list = [k.strip() for k in keywords.split("/") if k.strip()]
+                elif isinstance(keywords, list):
+                    keywords_list = keywords
+                else:
+                    keywords_list = []
+                return {"memory_text": memory_text, "keywords": keywords_list}
+            except Exception as parse_e:
+                logger.error(f"解析记忆json失败：{str(parse_e)} {traceback.format_exc()}")
+                return None
+        except Exception as e:
+            logger.error(f"构建记忆出现错误：{str(e)} {traceback.format_exc()}")
+            return None
+
+    async def create_and_store_memory(self, text):
+        if_need = await self.if_need_build(text)
+        if if_need:
+            logger.info(f"需要记忆：{text}")
+            memory = await self.build_memory(text)
+            if memory and memory.get("memory_text"):
+                memory_id = f"{self.chat_id}_{time.time()}"
+                memory_item = MemoryItem(
+                    memory_id=memory_id,
+                    chat_id=self.chat_id,
+                    memory_text=memory["memory_text"],
+                    keywords=memory.get("keywords", []),
+                )
+                await self.store_memory(memory_item)
+        else:
+            logger.info(f"不需要记忆：{text}")
+
+    async def store_memory(self, memory_item: MemoryItem):
+        memory = Memory(
+            memory_id=memory_item.memory_id,
+            chat_id=memory_item.chat_id,
+            memory_text=memory_item.memory_text,
+            keywords=memory_item.keywords,
+            create_time=memory_item.create_time,
+            last_view_time=memory_item.last_view_time,
+        )
+        session.add(memory)
+        session.commit()
+
+    async def get_memory(self, target: str):
+        from json_repair import repair_json
+
+        prompt = f"""
+        请根据以下发言内容，判断是否需要提取记忆
+        {target}
+        请用json格式输出，包含以下字段：
+        其中，time的要求是：
+        可以选择具体日期时间，格式为YYYY-MM-DD HH:MM:SS，或者大致时间，格式为YYYY-MM-DD
+        可以选择相对时间，例如：今天，昨天，前天，5天前，1个月前
+        可以选择留空进行模糊搜索
+        {{
+            "need_memory": 1,
+            "keywords": "希望获取的记忆关键词，用/划分",
+            "time": "希望获取的记忆大致时间"
+        }}
+        请只输出json格式，不要输出其他多余内容
+        """
+        try:
+            response, _ = await self.summary_model.generate_response_async(prompt, temperature=0.5)
+            print(prompt)
+            print(response)
+            if not response:
+                return None
+            try:
+                repaired = repair_json(response)
+                result = json.loads(repaired)
+                # 解析keywords
+                keywords = result.get("keywords", "")
+                if isinstance(keywords, str):
+                    keywords_list = [k.strip() for k in keywords.split("/") if k.strip()]
+                elif isinstance(keywords, list):
+                    keywords_list = keywords
+                else:
+                    keywords_list = []
+                # 解析time为时间段
+                time_str = result.get("time", "").strip()
+                start_time, end_time = self._parse_time_range(time_str)
+                logger.info(f"start_time: {start_time}, end_time: {end_time}")
+                # 检索包含关键词的记忆
+                memories_set = set()
+                if start_time and end_time:
+                    start_ts = start_time.timestamp()
+                    end_ts = end_time.timestamp()
+                    query = session.execute(select(Memory).where(
+                        (Memory.chat_id == self.chat_id)
+                        & (Memory.create_time >= start_ts)
+                        & (Memory.create_time < end_ts)
+                    )).scalars()
+                else:
+                    query = session.execute(select(Memory).where(Memory.chat_id == self.chat_id)).scalars()
+
+                for mem in query:
+                    # 对每条记忆
+                    mem_keywords = mem.keywords or ""
+                    parsed = ast.literal_eval(mem_keywords)
+                    if isinstance(parsed, list):
+                        mem_keywords = [str(k).strip() for k in parsed if str(k).strip()]
+                    else:
+                        mem_keywords = []
+                    # logger.info(f"mem_keywords: {mem_keywords}")
+                    # logger.info(f"keywords_list: {keywords_list}")
+                    for kw in keywords_list:
+                        # logger.info(f"kw: {kw}")
+                        # logger.info(f"kw in mem_keywords: {kw in mem_keywords}")
+                        if kw in mem_keywords:
+                            # logger.info(f"mem.memory_text: {mem.memory_text}")
+                            memories_set.add(mem.memory_text)
+                            break
+                return list(memories_set)
+            except Exception as parse_e:
+                logger.error(f"解析记忆json失败：{str(parse_e)} {traceback.format_exc()}")
+                return None
+        except Exception as e:
+            logger.error(f"获取记忆出现错误：{str(e)} {traceback.format_exc()}")
+            return None
+
+    def _parse_time_range(self, time_str):
+        # sourcery skip: extract-duplicate-method, use-contextlib-suppress
+        """
+        支持解析如下格式：
+        - 具体日期时间：YYYY-MM-DD HH:MM:SS
+        - 具体日期：YYYY-MM-DD
+        - 相对时间：今天，昨天，前天，N天前，N个月前
+        - 空字符串：返回(None, None)
+        """
+        now = datetime.now()
+        if not time_str:
+            return 0, now
+        time_str = time_str.strip()
+        # 具体日期时间
+        try:
+            dt = datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S")
+            return dt, dt + timedelta(hours=1)
+        except Exception:
+            pass
+        # 具体日期
+        try:
+            dt = datetime.strptime(time_str, "%Y-%m-%d")
+            return dt, dt + timedelta(days=1)
+        except Exception:
+            pass
+        # 相对时间
+        if time_str == "今天":
+            start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+            end = start + timedelta(days=1)
+            return start, end
+        if time_str == "昨天":
+            start = (now - timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+            end = start + timedelta(days=1)
+            return start, end
+        if time_str == "前天":
+            start = (now - timedelta(days=2)).replace(hour=0, minute=0, second=0, microsecond=0)
+            end = start + timedelta(days=1)
+            return start, end
+        if m := re.match(r"(\d+)天前", time_str):
+            days = int(m.group(1))
+            start = (now - timedelta(days=days)).replace(hour=0, minute=0, second=0, microsecond=0)
+            end = start + timedelta(days=1)
+            return start, end
+        if m := re.match(r"(\d+)个月前", time_str):
+            months = int(m.group(1))
+            # 近似每月30天
+            start = (now - timedelta(days=months * 30)).replace(hour=0, minute=0, second=0, microsecond=0)
+            end = start + timedelta(days=1)
+            return start, end
+        # 其他无法解析
+        return 0, now

src/chat/memory_system/memory_activator.py

@@ -0,0 +1,144 @@
+import difflib
+import json
+
+from json_repair import repair_json
+from typing import List, Dict
+from datetime import datetime
+
+from src.llm_models.utils_model import LLMRequest
+from src.config.config import global_config, model_config
+from src.common.logger import get_logger
+from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
+from src.chat.memory_system.Hippocampus import hippocampus_manager
+
+
+logger = get_logger("memory_activator")
+
+
+def get_keywords_from_json(json_str) -> List:
+    """
+    从JSON字符串中提取关键词列表
+
+    Args:
+        json_str: JSON格式的字符串
+
+    Returns:
+        List[str]: 关键词列表
+    """
+    try:
+        # 使用repair_json修复JSON格式
+        fixed_json = repair_json(json_str)
+
+        # 如果repair_json返回的是字符串，需要解析为Python对象
+        result = json.loads(fixed_json) if isinstance(fixed_json, str) else fixed_json
+        return result.get("keywords", [])
+    except Exception as e:
+        logger.error(f"解析关键词JSON失败: {e}")
+        return []
+
+
+def init_prompt():
+    # --- Group Chat Prompt ---
+    memory_activator_prompt = """
+    你是一个记忆分析器，你需要根据以下信息来进行回忆
+    以下是一段聊天记录，请根据这些信息，总结出几个关键词作为记忆回忆的触发词
+    
+    聊天记录:
+    {obs_info_text}
+    你想要回复的消息:
+    {target_message}
+    
+    历史关键词（请避免重复提取这些关键词）：
+    {cached_keywords}
+    
+    请输出一个json格式，包含以下字段：
+    {{
+        "keywords": ["关键词1", "关键词2", "关键词3",......]
+    }}
+    不要输出其他多余内容，只输出json格式就好
+    """
+
+    Prompt(memory_activator_prompt, "memory_activator_prompt")
+
+
+class MemoryActivator:
+    def __init__(self):
+        self.key_words_model = LLMRequest(
+            model_set=model_config.model_task_config.utils_small,
+            request_type="memory.activator",
+        )
+
+        self.running_memory = []
+        self.cached_keywords = set()  # 用于缓存历史关键词
+
+    async def activate_memory_with_chat_history(self, target_message, chat_history_prompt) -> List[Dict]:
+        """
+        激活记忆
+        """
+        # 如果记忆系统被禁用，直接返回空列表
+        if not global_config.memory.enable_memory:
+            return []
+
+        # 将缓存的关键词转换为字符串，用于prompt
+        cached_keywords_str = ", ".join(self.cached_keywords) if self.cached_keywords else "暂无历史关键词"
+
+        prompt = await global_prompt_manager.format_prompt(
+            "memory_activator_prompt",
+            obs_info_text=chat_history_prompt,
+            target_message=target_message,
+            cached_keywords=cached_keywords_str,
+        )
+
+        # logger.debug(f"prompt: {prompt}")
+
+        response, (reasoning_content, model_name, _) = await self.key_words_model.generate_response_async(
+            prompt, temperature=0.5
+        )
+
+        keywords = list(get_keywords_from_json(response))
+
+        # 更新关键词缓存
+        if keywords:
+            # 限制缓存大小，最多保留10个关键词
+            if len(self.cached_keywords) > 10:
+                # 转换为列表，移除最早的关键词
+                cached_list = list(self.cached_keywords)
+                self.cached_keywords = set(cached_list[-8:])
+
+            # 添加新的关键词到缓存
+            self.cached_keywords.update(keywords)
+
+        # 调用记忆系统获取相关记忆
+        related_memory = await hippocampus_manager.get_memory_from_topic(
+            valid_keywords=keywords, max_memory_num=3, max_memory_length=2, max_depth=3
+        )
+
+        logger.debug(f"当前记忆关键词: {self.cached_keywords} ")
+        logger.debug(f"获取到的记忆: {related_memory}")
+
+        # 激活时，所有已有记忆的duration+1，达到3则移除
+        for m in self.running_memory[:]:
+            m["duration"] = m.get("duration", 1) + 1
+        self.running_memory = [m for m in self.running_memory if m["duration"] < 3]
+
+        if related_memory:
+            for topic, memory in related_memory:
+                # 检查是否已存在相同topic或相似内容（相似度>=0.7）的记忆
+                exists = any(
+                    m["topic"] == topic or difflib.SequenceMatcher(None, m["content"], memory).ratio() >= 0.7
+                    for m in self.running_memory
+                )
+                if not exists:
+                    self.running_memory.append(
+                        {"topic": topic, "content": memory, "timestamp": datetime.now().isoformat(), "duration": 1}
+                    )
+                    logger.debug(f"添加新记忆: {topic} - {memory}")
+
+        # 限制同时加载的记忆条数，最多保留最后3条
+        if len(self.running_memory) > 3:
+            self.running_memory = self.running_memory[-3:]
+
+        return self.running_memory
+
+
+init_prompt()

src/chat/memory_system/sample_distribution.py

@@ -0,0 +1,126 @@
+import numpy as np
+from datetime import datetime, timedelta
+from rich.traceback import install
+
+install(extra_lines=3)
+
+
+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): 要生成的总时间点数量
+        """
+        # 验证参数
+        if total_samples <= 0:
+            raise ValueError("total_samples 必须大于0")
+        if weight1 < 0 or weight2 < 0:
+            raise ValueError("权重必须为非负数")
+        if std_hours1 < 0 or std_hours2 < 0:
+            raise ValueError("标准差必须为非负数")
+
+        # 归一化权重
+        total_weight = weight1 + weight2
+        if total_weight == 0:
+            raise ValueError("权重总和不能为0")
+        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 = max(1, int(self.total_samples * self.weight1))
+        samples2 = max(1, self.total_samples - samples1)  # 确保 samples2 至少为1
+
+        # 生成两个正态分布的小时偏移
+        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("]")