mem1 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

mem1/__init__.py

@@ -1,9 +1,15 @@
 """
 Mem1 - 基于 Elasticsearch 的用户记忆系统
 """
+import logging
 
 __version__ = "0.0.5"
 
+# 屏蔽第三方库的详细日志（必须在导入前设置）
+logging.getLogger("elastic_transport").setLevel(logging.WARNING)
+logging.getLogger("elastic_transport.transport").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+
 from mem1.memory_es import Mem1Memory
 from mem1.config import Mem1Config, LLMConfig
 

mem1/config.py

@@ -1,5 +1,6 @@
 """配置管理"""
 import os
+from typing import Optional
 from pydantic import BaseModel
 
 
@@ -11,6 +12,24 @@ class LLMConfig(BaseModel):
     base_url: str
 
 
+class VLConfig(BaseModel):
+    """视觉语言模型配置（可选，配置了 provider 即启用）
+    
+    支持的 provider:
+    - qwen: 使用 dashscope SDK 调用 Qwen-VL
+    - doubao: 使用 OpenAI 兼容接口调用豆包视觉模型
+    """
+    provider: str = ""  # qwen / doubao
+    model: str = ""
+    api_key: str = ""
+    base_url: str = ""  # doubao 需要
+    
+    @property
+    def enabled(self) -> bool:
+        """配置了 provider 就启用"""
+        return bool(self.provider)
+
+
 class MemoryConfig(BaseModel):
     """记忆系统配置"""
     memory_dir: str
@@ -37,6 +56,7 @@ class ImagesConfig(BaseModel):
 class Mem1Config(BaseModel):
     """Mem1 总配置"""
     llm: LLMConfig
+    vl: VLConfig
     memory: MemoryConfig
     es: ESConfig
     images: ImagesConfig
@@ -56,6 +76,10 @@ class Mem1Config(BaseModel):
         - MEM1_MAX_PROFILE_CHARS: 画像最大字符数
         - MEM1_UPDATE_INTERVAL_ROUNDS: 画像更新间隔轮数
         - MEM1_UPDATE_INTERVAL_MINUTES: 画像更新间隔分钟数
+        
+        可选的环境变量（VL 模型，使用 dashscope SDK）：
+        - MEM1_VL_MODEL: VL 模型名（如 qwen-vl-max），配置即启用
+        - MEM1_VL_API_KEY: dashscope API 密钥
         """
         # 必需配置检查
         required_vars = {
@@ -84,6 +108,14 @@ class Mem1Config(BaseModel):
         memory_dir = required_vars["MEM1_MEMORY_DIR"]
         images_dir = f"{memory_dir}/images"
         
+        # VL 模型配置（可选，配置了 provider 即启用）
+        vl_config = VLConfig(
+            provider=os.getenv("MEM1_VL_PROVIDER", ""),
+            model=os.getenv("MEM1_VL_MODEL", ""),
+            api_key=os.getenv("MEM1_VL_API_KEY", ""),
+            base_url=os.getenv("MEM1_VL_BASE_URL", "")
+        )
+        
         return cls(
             llm=LLMConfig(
                 provider="openai",
@@ -91,6 +123,7 @@ class Mem1Config(BaseModel):
                 api_key=required_vars["MEM1_LLM_API_KEY"],
                 base_url=required_vars["MEM1_LLM_BASE_URL"]
             ),
+            vl=vl_config,
             memory=MemoryConfig(
                 memory_dir=memory_dir,
                 auto_update_profile=required_vars["MEM1_AUTO_UPDATE_PROFILE"].lower() == "true",

mem1/llm.py

@@ -1,7 +1,7 @@
 """LLM 客户端"""
-from typing import List, Dict
+from typing import List, Dict, Optional
 from openai import OpenAI
-from mem1.config import LLMConfig
+from mem1.config import LLMConfig, VLConfig
 
 
 class LLMClient:
@@ -41,3 +41,99 @@ class LLMClient:
         response = self.client.chat.completions.create(**kwargs)
         
         return response.choices[0].message.content
+
+
+class VLClient:
+    """视觉语言模型客户端（支持 qwen/doubao）"""
+    
+    def __init__(self, config: VLConfig):
+        self.config = config
+        self.provider = config.provider.lower()
+        
+        if self.provider == "qwen":
+            import dashscope
+            dashscope.api_key = config.api_key
+        elif self.provider == "doubao":
+            self.client = OpenAI(
+                api_key=config.api_key,
+                base_url=config.base_url
+            )
+    
+    def understand_image(
+        self,
+        image_path: str,
+        user_description: str = ""
+    ) -> str:
+        """理解图片内容（OCR + 图片理解）
+        
+        Args:
+            image_path: 图片本地路径
+            user_description: 用户对图片的描述（可选）
+        
+        Returns:
+            图片理解结果（包含 OCR 文字和内容描述）
+        """
+        prompt = "请分析这张图片，完成以下任务：\n1. OCR识别：提取图片中的所有文字\n2. 内容理解：描述图片的主要内容和关键信息\n\n请用简洁的中文回答，格式如下：\n【文字内容】...\n【图片描述】..."
+        
+        if user_description:
+            prompt += f"\n\n用户补充说明：{user_description}"
+        
+        if self.provider == "qwen":
+            return self._call_qwen(image_path, prompt)
+        elif self.provider == "doubao":
+            return self._call_doubao(image_path, prompt)
+        else:
+            raise ValueError(f"不支持的 VL provider: {self.provider}")
+    
+    def _call_qwen(self, image_path: str, prompt: str) -> str:
+        """调用 Qwen-VL（dashscope SDK）"""
+        import dashscope
+        
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"image": image_path},
+                    {"text": prompt}
+                ]
+            }
+        ]
+        
+        response = dashscope.MultiModalConversation.call(
+            model=self.config.model,
+            messages=messages
+        )
+        
+        return response.output.choices[0].message.content[0]["text"]
+    
+    def _call_doubao(self, image_path: str, prompt: str) -> str:
+        """调用豆包视觉模型（OpenAI 兼容接口）"""
+        import base64
+        
+        # 读取图片并转为 base64
+        with open(image_path, "rb") as f:
+            image_data = base64.b64encode(f.read()).decode("utf-8")
+        
+        # 获取图片格式
+        ext = image_path.lower().split(".")[-1]
+        mime_type = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg", "gif": "image/gif", "webp": "image/webp"}.get(ext, "image/png")
+        
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:{mime_type};base64,{image_data}"}
+                    },
+                    {"type": "text", "text": prompt}
+                ]
+            }
+        ]
+        
+        response = self.client.chat.completions.create(
+            model=self.config.model,
+            messages=messages
+        )
+        
+        return response.choices[0].message.content

mem1/memory_es.py

@@ -1,5 +1,5 @@
 """基于 Elasticsearch 的记忆管理系统"""
-import json
+import re
 import shutil
 import base64
 import logging
@@ -8,8 +8,8 @@ from typing import List, Dict, Any, Optional
 from pathlib import Path
 from elasticsearch import Elasticsearch
 from mem1.config import Mem1Config
-from mem1.llm import LLMClient
-from mem1.prompts import ProfileTemplate, RECALL_DECISION_PROMPT, IMAGE_SEARCH_PROMPT, ASSISTANT_SUMMARY_PROMPT
+from mem1.llm import LLMClient, VLClient
+from mem1.prompts import ProfileTemplate, RECALL_DECISION_PROMPT, IMAGE_SEARCH_PROMPT, ASSISTANT_SUMMARY_PROMPT, CONTEXT_SUFFICIENT_PROMPT
 
 logger = logging.getLogger(__name__)
 
@@ -23,10 +23,10 @@ class Mem1Memory:
     """基于 Elasticsearch 的用户记忆系统
     
     数据存储（全部在 ES）：
-    - ES 索引 conversation_history: 历史对话记录（按 user_id + topic_id 隔离）
+    - ES 索引 {index_name}: 历史对话记录 + 图片索引（按 user_id + topic_id 隔离）
     - ES 索引 mem1_user_state: 用户更新状态（轮数、上次更新时间）
     - ES 索引 mem1_user_profile: 用户画像（按 user_id 共享，跨话题）
-    - 本地文件 _images.json: 图片索引（仅图片相关）
+    - 本地文件: 图片文件存储
     """
     
     def __init__(
@@ -63,6 +63,9 @@ class Mem1Memory:
         # LLM 客户端
         self.llm = LLMClient(config.llm)
         
+        # VL 客户端（可选）
+        self.vl = VLClient(config.vl) if config.vl.enabled else None
+        
         # 业务场景模板
         self.profile_template = profile_template or ProfileTemplate()
         
@@ -74,7 +77,7 @@ class Mem1Memory:
         self.save_assistant_messages = config.memory.save_assistant_messages
         self.max_assistant_chars = config.memory.max_assistant_chars
         
-        # 确保用户状态索引存在
+        # 确保索引存在
         self._ensure_state_index()
     
     def _get_user_images_dir(self, user_id: str) -> Path:
@@ -83,21 +86,36 @@ class Mem1Memory:
         images_dir.mkdir(parents=True, exist_ok=True)
         return images_dir
     
-    def _get_images_index_path(self, user_id: str) -> Path:
-        """获取图片索引文件路径"""
-        return self.images_dir / user_id / "_images.json"
-    
     def _load_images_index(self, user_id: str) -> List[Dict[str, str]]:
-        """加载图片索引"""
-        path = self._get_images_index_path(user_id)
-        if path.exists():
-            return json.loads(path.read_text(encoding="utf-8"))
-        return []
+        """从对话记录中提取用户所有图片"""
+        try:
+            response = self.es.search(
+                index=self.index_name,
+                query={
+                    "bool": {
+                        "must": [
+                            {"term": {"user_id": user_id}},
+                            {"exists": {"field": "images"}}
+                        ]
+                    }
+                },
+                size=1000,
+                sort=[{"timestamp": {"order": "asc"}}]
+            )
+            
+            images = []
+            for hit in response["hits"]["hits"]:
+                conv_images = hit["_source"].get("images", [])
+                images.extend(conv_images)
+            return images
+        except Exception:
+            return []
     
-    def _save_images_index(self, user_id: str, index: List[Dict[str, str]]) -> None:
-        """保存图片索引"""
-        path = self._get_images_index_path(user_id)
-        path.write_text(json.dumps(index, ensure_ascii=False, indent=2), encoding="utf-8")
+    def _save_image_to_conversation(self, conversation_entry: Dict, image_doc: Dict[str, str]) -> None:
+        """将图片信息添加到对话记录"""
+        if "images" not in conversation_entry:
+            conversation_entry["images"] = []
+        conversation_entry["images"].append(image_doc)
     
     def _get_profile(self, user_id: str) -> Optional[str]:
         """从 ES 获取用户画像"""
@@ -264,11 +282,19 @@ class Mem1Memory:
         user_id = self.user_id
         topic_id = self.topic_id
         
+        # 构建对话记录
+        conversation_entry = {
+            "user_id": user_id,
+            "topic_id": topic_id,
+            "timestamp": ts,
+            "messages": [],
+            "metadata": metadata or {}
+        }
+        
         # 处理图片
         image_refs = []
         if images:
             user_images_dir = self._get_user_images_dir(user_id)
-            images_index = self._load_images_index(user_id)
             timestamp_str = datetime.now().strftime('%Y%m%d_%H%M%S')
             
             for img in images:
@@ -281,46 +307,49 @@ class Mem1Memory:
                 elif 'path' in img:
                     shutil.copy(img['path'], img_path)
                 
-                rel_path = f"./images/{filename}"
-                image_refs.append(rel_path)
+                image_refs.append(filename)
+                
+                # 生成图片描述（用户描述 + VL 理解）
+                user_desc = ""
+                for msg in messages:
+                    if msg["role"] == "user":
+                        user_desc = msg["content"]
+                        break
                 
-                description = img.get('description', '')
-                if not description:
-                    for msg in messages:
-                        if msg["role"] == "user":
-                            description = msg["content"][:100]
-                            break
+                # 如果启用了 VL 模型，调用视觉理解
+                if self.vl:
+                    try:
+                        vl_result = self.vl.understand_image(str(img_path), user_desc)
+                        if user_desc:
+                            description = f"【用户描述】{user_desc}\n\n{vl_result}"
+                        else:
+                            description = vl_result
+                        logger.info(f"🖼️ VL 图片理解完成: {filename}")
+                    except Exception as e:
+                        logger.warning(f"⚠️ VL 图片理解失败: {e}, 使用用户描述")
+                        description = user_desc or img['filename']
+                else:
+                    description = user_desc or img['filename']
                 
-                images_index.append({
+                # 图片信息存入对话记录
+                self._save_image_to_conversation(conversation_entry, {
                     "filename": filename,
-                    "path": rel_path,
                     "description": description,
                     "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                     "original_name": img['filename']
                 })
-            
-            self._save_images_index(user_id, images_index)
-        
-        # 构建对话记录（包含 topic_id）
-        conversation_entry = {
-            "user_id": user_id,
-            "topic_id": topic_id,
-            "timestamp": ts,
-            "messages": [],
-            "metadata": metadata or {}
-        }
         
+        # 处理消息
         first_user_msg = True
         for msg in messages:
             if msg["role"] == "user":
                 msg_obj = {"role": "user", "content": msg["content"]}
                 if first_user_msg and image_refs:
-                    msg_obj["images"] = image_refs
+                    msg_obj["image_refs"] = image_refs
                     first_user_msg = False
                 conversation_entry["messages"].append(msg_obj)
             elif self.save_assistant_messages and msg["role"] == "assistant":
                 content = msg["content"]
-                # 超长回复触发摘要
                 if len(content) > self.max_assistant_chars:
                     content = self._summarize_assistant_response(content)
                 conversation_entry["messages"].append({
@@ -515,6 +544,148 @@ class Mem1Memory:
             "profile_last_updated": profile_last_updated
         }
     
+    def get_context_progressive(
+        self,
+        query: str,
+        max_days: int = 31,
+        step: int = 7
+    ) -> Dict[str, Any]:
+        """渐进式检索：每次多查一周，直到 LLM 认为信息足够
+        
+        Args:
+            query: 用户问题
+            max_days: 最大检索天数，默认31天
+            step: 每步增加的天数，默认7天
+        """
+        user_id = self.user_id
+        profile_content = self._init_profile(user_id)
+        
+        now = datetime.now()
+        weekdays = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
+        current_time = f"{now.strftime('%Y-%m-%d %H:%M')} {weekdays[now.weekday()]}"
+        
+        # 从 ES 获取画像更新时间
+        profile_last_updated = "未更新"
+        try:
+            response = self.es.get(index=USER_PROFILE_INDEX, id=user_id)
+            profile_last_updated = response["_source"].get("updated_at", "未更新")
+        except Exception:
+            pass
+        
+        # 渐进式检索
+        all_conversations = []
+        searched_days = 0
+        
+        for end_day in range(step, max_days + step, step):
+            end_day = min(end_day, max_days)
+            
+            # 检索这个时间段的对话
+            new_conversations = self._get_conversations_range(searched_days, end_day)
+            all_conversations.extend(new_conversations)
+            searched_days = end_day
+            
+            if not all_conversations:
+                logger.info(f"📖 渐进检索: 0-{end_day}天 无对话，继续...")
+                continue
+            
+            # LLM 判断信息是否足够
+            normal_content = self._format_conversations_for_llm(all_conversations)
+            if self._is_context_sufficient(query, profile_content, normal_content, end_day):
+                logger.info(f"✓ 渐进检索完成: 0-{end_day}天，{len(all_conversations)}条对话")
+                break
+            
+            logger.info(f"📖 渐进检索: 0-{end_day}天 信息不足，继续...")
+        
+        normal_content = self._format_conversations_for_llm(all_conversations) if all_conversations else ""
+        
+        return {
+            "current_time": current_time,
+            "user_id": user_id,
+            "topic_id": self.topic_id,
+            "import_content": profile_content,
+            "normal_content": normal_content,
+            "conversations_count": len(all_conversations),
+            "profile_last_updated": profile_last_updated,
+            "searched_days": searched_days
+        }
+    
+    def _get_conversations_range(
+        self,
+        start_days_ago: int,
+        end_days_ago: int
+    ) -> List[Dict[str, Any]]:
+        """获取指定天数范围内的对话（start_days_ago 到 end_days_ago 天前）"""
+        user_id = self.user_id
+        topic_id = self.topic_id
+        
+        now = datetime.now()
+        start_date = (now - timedelta(days=end_days_ago)).strftime('%Y-%m-%d %H:%M:%S')
+        end_date = (now - timedelta(days=start_days_ago)).strftime('%Y-%m-%d %H:%M:%S')
+        
+        query = {
+            "bool": {
+                "must": [
+                    {"term": {"user_id": user_id}},
+                    {"term": {"topic_id": topic_id}},
+                    {"range": {"timestamp": {"gte": start_date, "lt": end_date}}}
+                ]
+            }
+        }
+        
+        response = self.es.search(
+            index=self.index_name,
+            query=query,
+            size=1000,
+            sort=[{"timestamp": {"order": "asc"}}]
+        )
+        
+        return [hit["_source"] for hit in response["hits"]["hits"]]
+    
+    def _is_context_sufficient(
+        self,
+        query: str,
+        profile: str,
+        conversations: str,
+        days: int
+    ) -> bool:
+        """LLM 判断当前上下文是否足够回答问题"""
+        prompt = CONTEXT_SUFFICIENT_PROMPT.format(
+            query=query,
+            profile=profile,
+            conversations=conversations or "（无对话记录）",
+            days=days
+        )
+        
+        messages = [
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": query}
+        ]
+        
+        response = self.llm.generate(messages, response_format="text")
+        is_sufficient = "true" in response.strip().lower()
+        
+        return is_sufficient
+    
+    def search_conversations(
+        self,
+        start_days: int,
+        end_days: int
+    ) -> List[Dict[str, Any]]:
+        """按时间范围检索对话（供外部 LLM 作为 tool 调用）
+        
+        Args:
+            start_days: 起始天数（距今多少天，较近）
+            end_days: 结束天数（距今多少天，较远）
+        
+        Returns:
+            对话记录列表
+        
+        示例:
+            search_conversations(0, 7)    # 最近7天
+            search_conversations(170, 180) # 约半年前的10天
+        """
+        return self._get_conversations_range(start_days, end_days)
+    
     def _compress_profile(self, user_id: str, profile_content: str) -> str:
         """压缩用户画像"""
         timestamp = datetime.now().strftime('%Y-%m-%d %H:%M')
@@ -575,7 +746,7 @@ class Mem1Memory:
             return []
         
         images_desc = "\n".join([
-            f"[{i}] 文件名: {img['original_name']}, 时间: {img['timestamp']}, 描述: {img['description'][:100]}"
+            f"[{i}] 文件名: {img['original_name']}, 时间: {img['timestamp']}, 描述: {img['description']}"
             for i, img in enumerate(images_index)
         ])
         
@@ -589,12 +760,16 @@ class Mem1Memory:
         response = self.llm.generate(messages, response_format="text")
         
         results = []
-        for line in response.strip().split('\n'):
-            line = line.strip()
-            if line.isdigit():
-                idx = int(line)
-                if 0 <= idx < len(images_index):
-                    results.append(images_index[idx])
+        # 提取所有数字（支持多种格式：纯数字、[0]、0. 等）
+        import re
+        numbers = re.findall(r'\b(\d+)\b', response)
+        for num_str in numbers:
+            idx = int(num_str)
+            if 0 <= idx < len(images_index):
+                img = images_index[idx].copy()
+                img['abs_path'] = str((self._get_user_images_dir(user_id) / img['filename']).resolve())
+                if img not in results:  # 去重
+                    results.append(img)
         
         logger.info(f"🖼️ 图片搜索: query='{query}', 找到 {len(results)} 张")
         return results

mem1/prompts.py

@@ -32,6 +32,14 @@ class ProfileTemplate:
 - 关注重点：
 - 特殊要求：
 
+## 周期性任务
+（固定日程和重复性工作，格式：[周期] 任务内容）
+- 例：[每周一] 提交周报、[每周五] 制定下周计划、[每月底] 月度汇总
+
+## 关键数据
+（重要的数字、金额、数量，用加粗标记）
+- 例：处置 **97起** 案件、涉及金额 **230万元**、完成 **365个** 检查点
+
 ## 任务时间线
 （用户提到的计划、截止日期、里程碑，格式：[YYYY-MM-DD] 事项）
 
@@ -111,15 +119,26 @@ DEFAULT_PROFILE_UPDATE_PROMPT = """你是用户画像分析专家。从对话记
 4. 只记录用户明确表达的信息，不要推测
 5. 如果某个章节没有信息，保留标题但内容留空
 
+## 周期性任务提取
+6. 识别固定日程：用户提到"每周一"、"每周五"、"每天"、"每月"等周期性任务
+7. 记录到「周期性任务」章节，格式：[周期] 任务内容
+8. 示例：[每周一] 提交周报、[每周五] 制定下周计划
+
+## 关键数字保留【重要】
+9. 所有具体数字必须原样保留并用 **加粗** 标记，禁止概括为"多个"、"若干"、"大量"
+10. 记录到「关键数据」章节，格式：事项描述 **数字**
+11. 正确示例：处置 **97起** 案件、涉及金额 **230万元** ✓
+12. 错误示例：处置多起案件、涉及大额资金 ✗
+
 ## 时间敏感信息提取
-6. 任务时间线：提取用户提到的日期、截止时间、计划安排、里程碑，记录到「任务时间线」
-7. 待办事项：识别用户说"下次"、"回头"、"先这样"、"稍后"、"改天"等挂起信号，将未完成的请求记录到「待办事项」
-8. 已完成事项：如果对话中确认某个待办已完成，将其从「待办事项」移除或标记为 [x]
+13. 任务时间线：提取用户提到的日期、截止时间、计划安排、里程碑，记录到「任务时间线」
+14. 待办事项：识别用户说"下次"、"回头"、"先这样"、"稍后"、"改天"等挂起信号，将未完成的请求记录到「待办事项」
+15. 已完成事项：如果对话中确认某个待办已完成，将其从「待办事项」移除或标记为 [x]
 
 ## 矛盾检测
-9. 发现用户前后说法矛盾时（如偏好、身份、需求不一致），不要直接覆盖旧信息
-10. 将矛盾记录到「待澄清事项」，格式：⚠️ 用户曾说"..."（日期），但又说"..."（日期）
-11. 只有用户明确澄清后，才能更新对应信息并移除待澄清标记
+16. 发现用户前后说法矛盾时（如偏好、身份、需求不一致），不要直接覆盖旧信息
+17. 将矛盾记录到「待澄清事项」，格式：⚠️ 用户曾说"..."（日期），但又说"..."（日期）
+18. 只有用户明确澄清后，才能更新对应信息并移除待澄清标记
 
 ---
 *最后更新: {timestamp}*
@@ -188,6 +207,28 @@ ASSISTANT_SUMMARY_PROMPT = """你是对话摘要专家。将助手的长回复
 直接输出摘要内容，开头标注 [摘要]"""
 
 
+# ============ 渐进式检索判断提示词 ============
+
+CONTEXT_SUFFICIENT_PROMPT = """判断当前信息是否足够回答用户问题。
+
+## 用户问题
+{query}
+
+## 用户画像
+{profile}
+
+## 已检索的对话记录（最近 {days} 天）
+{conversations}
+
+## 判断标准
+- 如果画像或对话中包含回答问题所需的信息，输出 `true`
+- 如果问题涉及的时间、事件、数据在已有信息中找不到，输出 `false`
+- 如果是通用问题（不依赖历史记录），输出 `true`
+
+## 输出
+只输出：`true`（信息足够）或 `false`（需要检索更早的记录）"""
+
+
 # ============ 图片搜索提示词（通用） ============
 
 IMAGE_SEARCH_PROMPT = """根据用户查询，从图片列表中找出匹配的图片。
@@ -220,6 +261,14 @@ YUQING_PROFILE_TEMPLATE = ProfileTemplate(
 - 关注重点：（时效性/准确性/全面性等）
 - 图表偏好：
 
+## 周期性任务
+（固定日程和重复性工作，格式：[周期] 任务内容）
+- 例：[每周一] 提交周报、[每周五] 制定下周计划、[每月底] 月度汇总
+
+## 关键数据
+（重要的数字、金额、数量，用加粗标记）
+- 例：处置 **97起** 案件、涉及金额 **230万元**
+
 ## 任务时间线
 （报告截止日期、汇报计划、定期任务，格式：[YYYY-MM-DD] 事项）
 

mem1-0.0.7.dist-info/METADATA

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: mem1
+Version: 0.0.7
+Summary: 基于云服务的用户记忆系统
+Project-URL: Homepage, https://github.com/sougannkyou/mem1
+Project-URL: Repository, https://github.com/sougannkyou/mem1
+Author: Song
+License: MIT
+Keywords: langchain,llm,memory,user-profile
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Requires-Dist: dashscope>=1.14.0
+Requires-Dist: elasticsearch>=8.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: ipython>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mem1 - 用户记忆系统
+
+让 AI 真正"记住"用户：三层记忆架构 + 图片记忆 + 话题隔离 + 业务场景解耦。
+
+## 核心特性
+
+- **三层记忆架构**：短期会话 → 用户画像 → 长期记录
+- **话题隔离**：同一用户可有多个话题，对话按话题隔离，画像跨话题共享
+- **图片记忆**：存储图片时自动调用 VL 模型生成描述（OCR + 内容理解），搜索时基于文字描述召回
+- **业务解耦**：通过 ProfileTemplate 适配不同场景
+- **画像自动更新**：基于对话轮数/时间自动触发 LLM 更新用户画像
+
+## 安装
+
+```bash
+pip install mem1
+```
+
+## 快速开始
+
+```python
+from mem1 import Mem1Memory, Mem1Config
+
+# 从环境变量加载配置
+config = Mem1Config.from_env()
+
+# 创建记忆实例（绑定用户和话题）
+memory = Mem1Memory(config, user_id="user001", topic_id="project_a")
+
+# 添加对话
+memory.add_conversation(
+    messages=[
+        {"role": "user", "content": "你好，我是张明"},
+        {"role": "assistant", "content": "你好张明！"}
+    ]
+)
+
+# 获取上下文（含用户画像 + 最近对话）
+ctx = memory.get_context()
+print(ctx['import_content'])   # 用户画像
+print(ctx['normal_content'])   # 最近对话记录
+print(ctx['current_time'])     # 当前时间
+```
+
+## 环境变量配置
+
+复制 `.env.example` 为 `.env` 并填写配置：
+
+```bash
+cp .env.example .env
+```
+
+## 图片记忆
+
+存储图片时自动调用 VL 模型（如 Qwen-VL）生成描述：
+- 【用户描述】用户发送图片时的文字说明
+- 【文字内容】OCR 识别图片中的文字
+- 【图片描述】VL 模型对图片内容的理解
+
+搜索时基于描述文本进行关键词匹配，返回图片路径。
+
+```python
+# 添加带图片的对话
+memory.add_conversation(
+    messages=[{"role": "user", "content": "这是今天的报表"}],
+    images=[{"path": "./report.png", "filename": "report.png"}]
+)
+
+# 搜索图片（基于 VL 生成的描述）
+results = memory.search_images(query="报表")
+# 返回: [{"filename": "...", "description": "...", "abs_path": "..."}]
+```
+
+## LangChain 集成
+
+完整示例（记忆存储 + 召回）：
+
+```python
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import SystemMessage, HumanMessage
+from mem1 import Mem1Memory, Mem1Config
+
+config = Mem1Config.from_env()
+memory = Mem1Memory(config, user_id="user001", topic_id="project_a")
+llm = ChatOpenAI(model=config.llm.model, api_key=config.llm.api_key, base_url=config.llm.base_url)
+
+# ========== 第一次对话：存储记忆 ==========
+memory.add_conversation(messages=[
+    {"role": "user", "content": "我是李明，市网信办的，每周一要交周报"},
+    {"role": "assistant", "content": "李明您好！已记录：周一交周报。"}
+])
+memory.add_conversation(messages=[
+    {"role": "user", "content": "本月处理了97起舆情，重大舆情11起"},
+    {"role": "assistant", "content": "已记录本月数据。"}
+])
+
+# ========== 第二次对话：召回记忆 ==========
+user_question = "帮我写个本月舆情简报"
+
+# 1. 获取记忆上下文
+ctx = memory.get_context(query=user_question, days_limit=7)
+
+# 2. 构建 system prompt（注入画像 + 历史对话）
+system_prompt = f"""你是舆情助手。
+
+## 用户画像
+{ctx['import_content']}
+
+## 最近对话记录
+{ctx['normal_content']}
+
+## 当前时间
+{ctx['current_time']}
+
+## 重要规则
+- 回答必须基于对话记录，不要编造
+- 数字必须从记录中原样提取
+"""
+
+# 3. 调用 LLM（记忆已注入）
+messages = [SystemMessage(content=system_prompt), HumanMessage(content=user_question)]
+response = llm.invoke(messages)
+print(response.content)  # AI 会基于记忆中的 97起、11起 来回答
+
+# 4. 保存本次对话
+memory.add_conversation(messages=[
+    {"role": "user", "content": user_question},
+    {"role": "assistant", "content": response.content}
+])
+```
+
+## 核心接口
+
+```python
+memory = Mem1Memory(config, user_id="user001", topic_id="project_a")
+
+# 添加对话
+memory.add_conversation(messages=[...], images=[...], metadata={...})
+
+# 获取上下文（画像 + 最近 N 天对话）
+ctx = memory.get_context(days_limit=31)
+
+# 渐进式检索（先查近期，不够再扩展）
+ctx = memory.get_context_progressive(query="帮我写周报", max_days=31, step=7)
+
+# 按时间范围检索（供外部 LLM 作为 tool 调用）
+convs = memory.search_conversations(start_days=170, end_days=180)  # 查半年前
+
+# 查询对话
+convs = memory.get_conversations(days_limit=7)
+all_convs = memory.get_all_conversations(days_limit=7)
+
+# 图片搜索
+results = memory.search_images(query="麻花")
+
+# 话题管理
+topics = memory.list_topics()
+memory.delete_topic()
+memory.delete_user()
+```
+
+## 远期记忆检索
+
+mem1 定位是**记忆存储层**，不内置时间意图解析。当用户问"半年前的XX事"时，建议：
+
+1. **外部 LLM 判断时间范围**：通过 function calling 让 LLM 提取时间意图
+2. **调用 `search_conversations(start_days, end_days)`**：定向检索指定时间段
+
+```python
+# 示例：作为 LangChain Tool 暴露给 LLM
+from langchain.tools import tool
+
+@tool
+def search_memory(start_days: int, end_days: int) -> str:
+    """搜索用户历史对话。start_days 和 end_days 表示距今多少天。"""
+    convs = memory.search_conversations(start_days=start_days, end_days=end_days)
+    return memory._format_conversations_for_llm(convs)
+```
+
+这样设计的原因：
+- 外部 LLM 有完整对话上下文，判断时间范围更准确
+- 避免 mem1 内部嵌套 LLM 调用，架构更清晰
+- 符合 Agent / function calling 的设计模式
+
+## ES 索引
+
+| 索引 | 用途 |
+|------|------|
+| `conversation_history` | 对话记录（含图片索引） |
+| `mem1_user_state` | 用户状态 |
+| `mem1_user_profile` | 用户画像 |
+
+## LLM 提示词建议
+
+使用 `get_context()` 获取上下文后，建议在 system prompt 中加入以下规则，避免 LLM 编造信息：
+
+```
+## 重要规则
+1. 回答必须基于上述对话记录中的实际内容，严禁编造任何信息
+2. 涉及数字（金额、数量、百分比、日期等）时，必须从对话记录中原样提取，不得估算或编造
+3. 需要汇总累加时，必须列出计算过程（如：23+31+18+25=97）
+4. 涉及人名、公司名、账号名等实体时，必须使用对话中的原始名称
+5. 如果对话记录中没有相关信息，请明确说"对话记录中未提及"，不要猜测
+```
+
+## 设计决策：为什么不用 Context Caching
+
+豆包等大模型提供了 Context Caching 功能（缓存命中可省 86% token 费），但 mem1 选择不使用：
+
+| 对比 | Context Caching | mem1 架构 |
+|------|-----------------|-----------|
+| 原理 | 缓存整个对话历史，按 session 复用 | 画像压缩 + 按需检索 |
+| 适用场景 | 单 session 内反复分析同一长文档 | 跨 session 持久化记忆 |
+| 多模态 | Responses API 支持图片/视频缓存 | 图片转描述文本存储 |
+| 过期 | 72h 自动过期需重建 | ES 永久存储 |
+| 灵活性 | 固定缓存内容 | 动态组装 prompt |
+
+mem1 的记忆是动态组装的（画像 + 检索到的相关对话），每次 prompt 内容不同，Context Caching 的"相同前缀复用"优势无法发挥。
+
+如果担心 token 消耗，建议调小 `MEM1_CONTEXT_DAYS_LIMIT`（如 3-7 天），让远期记忆靠画像覆盖。
+
+## License
+
+MIT

mem1-0.0.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+mem1/__init__.py,sha256=tNsBrO4d7fujDIPpvl6pweVcg5kHr_EYRgslR8nWWEI,494
+mem1/config.py,sha256=9U-dJD6JsQ2CyDy-rwLqE3_kWwG3sPo7jTbkV_Tl4SE,5422
+mem1/langchain_middleware.py,sha256=h2mG7K2Tq1N7IovXMvCyvOhsAwTWOR1NAqivF4db2AE,6648
+mem1/llm.py,sha256=S23OA2OpZVb6A36iQ2YY_7Q7rRtnqC7xUbVW-bZSjsI,4419
+mem1/memory_es.py,sha256=keLiTq2yw2QC_tmIvCYSdOVnSJNpq981ko3GrQpsyjE,34301
+mem1/memory_md.py,sha256=uu_TvdBoUpAncT1eissOSe1Y3vCy3iWMcuvCy3vCjEA,26258
+mem1/memory_tools.py,sha256=b1YBiRNet0gXnW-KGIZ2KQclluB9Q6dli_DbWLS571k,3646
+mem1/prompts.py,sha256=5HUG-yvTD7iBUzzXwO-WnRomDLkz0UJWox3z3zcT0kI,10599
+mem1-0.0.7.dist-info/METADATA,sha256=VnJlMl-3KoG9zw59qA7xDKKoxo9Bzy1EeChu9EpjGhE,8300
+mem1-0.0.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mem1-0.0.7.dist-info/RECORD,,

mem1-0.0.5.dist-info/METADATA

@@ -1,139 +0,0 @@
-Metadata-Version: 2.4
-Name: mem1
-Version: 0.0.5
-Summary: 基于云服务的用户记忆系统
-Project-URL: Homepage, https://github.com/sougannkyou/mem1
-Project-URL: Repository, https://github.com/sougannkyou/mem1
-Author: Song
-License: MIT
-Keywords: langchain,llm,memory,user-profile
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.12
-Requires-Dist: elasticsearch>=8.0.0
-Requires-Dist: openai>=1.0.0
-Requires-Dist: pydantic>=2.0.0
-Requires-Dist: python-dotenv>=1.0.0
-Provides-Extra: dev
-Requires-Dist: ipython>=8.0.0; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# mem1 - 用户记忆系统
-
-让 AI 真正"记住"用户：三层记忆架构 + 图片记忆 + 话题隔离 + 业务场景解耦。
-
-## 核心特性
-
-- **三层记忆架构**：短期会话 → 用户画像 → 长期记录
-- **话题隔离**：同一用户可有多个话题，对话按话题隔离，画像跨话题共享
-- **图片记忆**：支持存储和语义搜索用户发送的图片
-- **业务解耦**：通过 ProfileTemplate 适配不同场景
-- **画像自动更新**：基于对话轮数/时间自动触发 LLM 更新用户画像
-
-## 安装
-
-```bash
-pip install mem1
-```
-
-## 快速开始
-
-```python
-from mem1 import Mem1Memory, Mem1Config
-
-# 从环境变量加载配置
-config = Mem1Config.from_env()
-
-# 创建记忆实例（绑定用户和话题）
-memory = Mem1Memory(config, user_id="user001", topic_id="project_a")
-
-# 添加对话
-memory.add_conversation(
-    messages=[
-        {"role": "user", "content": "你好，我是张明"},
-        {"role": "assistant", "content": "你好张明！"}
-    ]
-)
-
-# 获取上下文（含用户画像 + 最近对话）
-ctx = memory.get_context()
-print(ctx['import_content'])   # 用户画像
-print(ctx['normal_content'])   # 最近对话记录
-print(ctx['current_time'])     # 当前时间
-```
-
-## 环境变量配置
-
-```bash
-# LLM 配置
-MEM1_LLM_API_KEY=your-api-key
-MEM1_LLM_BASE_URL=https://api.deepseek.com
-MEM1_LLM_MODEL=deepseek-chat
-
-# ES 配置
-MEM1_ES_HOSTS=http://localhost:9200
-MEM1_ES_INDEX=conversation_history
-
-# 记忆配置
-MEM1_MEMORY_DIR=./memories
-MEM1_AUTO_UPDATE_PROFILE=true
-MEM1_MAX_PROFILE_CHARS=3000
-MEM1_UPDATE_INTERVAL_ROUNDS=5
-MEM1_UPDATE_INTERVAL_MINUTES=3
-MEM1_SAVE_ASSISTANT_MESSAGES=true
-MEM1_MAX_ASSISTANT_CHARS=500
-MEM1_CONTEXT_DAYS_LIMIT=31
-```
-
-## 核心接口
-
-```python
-memory = Mem1Memory(config, user_id="user001", topic_id="project_a")
-
-# 添加对话
-memory.add_conversation(messages=[...], images=[...], metadata={...})
-
-# 获取上下文（画像 + 最近 N 天对话）
-ctx = memory.get_context(days_limit=31)
-
-# 查询对话
-convs = memory.get_conversations(days_limit=7)
-all_convs = memory.get_all_conversations(days_limit=7)
-
-# 图片搜索
-results = memory.search_images(query="麻花")
-
-# 话题管理
-topics = memory.list_topics()
-memory.delete_topic()
-memory.delete_user()
-```
-
-## ES 索引
-
-| 索引 | 用途 |
-|------|------|
-| `conversation_history` | 对话记录 |
-| `mem1_user_state` | 用户状态 |
-| `mem1_user_profile` | 用户画像 |
-
-## LLM 提示词建议
-
-使用 `get_context()` 获取上下文后，建议在 system prompt 中加入以下规则，避免 LLM 编造信息：
-
-```
-## 重要规则
-1. 回答必须基于上述对话记录中的实际内容，严禁编造任何信息
-2. 涉及数字（金额、数量、百分比、日期等）时，必须从对话记录中原样提取，不得估算或编造
-3. 需要汇总累加时，必须列出计算过程（如：23+31+18+25=97）
-4. 涉及人名、公司名、账号名等实体时，必须使用对话中的原始名称
-5. 如果对话记录中没有相关信息，请明确说"对话记录中未提及"，不要猜测
-```
-
-## License
-
-MIT

mem1-0.0.5.dist-info/RECORD

@@ -1,11 +0,0 @@
-mem1/__init__.py,sha256=D-o5MjyTl565vqyVOyigm9LiZmsk9S5DfyV4QobLNo8,219
-mem1/config.py,sha256=Tr91k9P9T-znshYAFGSyL3KGNy38xQLjbSJWlHxxeIo,4309
-mem1/langchain_middleware.py,sha256=h2mG7K2Tq1N7IovXMvCyvOhsAwTWOR1NAqivF4db2AE,6648
-mem1/llm.py,sha256=EKsZHxLrRn-OTxCsPHOYcUTjnEF5RVMnEM8fqWzdkbg,1114
-mem1/memory_es.py,sha256=nVkZ2W-MWL0ZLzNqDoZ7e5Ccgde8SKzy2ogMm1CKZu8,27787
-mem1/memory_md.py,sha256=uu_TvdBoUpAncT1eissOSe1Y3vCy3iWMcuvCy3vCjEA,26258
-mem1/memory_tools.py,sha256=b1YBiRNet0gXnW-KGIZ2KQclluB9Q6dli_DbWLS571k,3646
-mem1/prompts.py,sha256=L0JGVa--V_h9KqqZnb1n1N9oaPqxBhxHFL71Us9J5qM,8685
-mem1-0.0.5.dist-info/METADATA,sha256=ZbNrxTHxutoP5zK65emlcymBSFagU2AE2dLhpX74bjE,3957
-mem1-0.0.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mem1-0.0.5.dist-info/RECORD,,