零基础 | AI应用记忆管理：从短期到长期的完整实践指南

zuozewei2026-01-26 16:46

文章目录

📄 文档概述

  • 创建时间：2026-01-25
  • 作者：zuozewei
  • 功能：AI应用记忆管理完整指南
  • 技术栈：Python、LangChain、mem0、ChromaDB、OpenAI API、DeepSeek
  • 项目路径 ：https://github.com/zuozewei/blog-example/tree/master/AI-LLM/

🔧 技术栈详解

版本兼容性说明

本文采用以下经过验证的版本组合：

  • Python 3.10+
  • LangChain v0.2.10
  • mem0 v1.1.2
  • ChromaDB v0.5.11

Python

定义：AI/ML领域的主流开发语言，生态系统成熟完善。

在本项目中的作用：

  • 作为主要开发语言，实现记忆管理逻辑
  • 丰富的AI/ML生态系统支持
  • 简洁易读的语法，便于快速开发

关键特性：

  • 动态类型系统
  • 强大的标准库
  • 跨平台支持
  • 活跃的社区支持

LangChain

定义：一个用于构建大模型应用的框架，提供模块化组件和工具链。

在本项目中的作用：

  • 提供聊天历史管理接口（BaseChatMessageHistory）
  • 实现文件持久化存储（FileChatMessageHistory）
  • 集成大模型调用（ChatOpenAI）
  • 提供提示词模板（ChatPromptTemplate）

核心组件：

  • ChatMessageHistories：管理对话历史记录
  • Chat Models：与大模型交互的接口
  • Prompts：提示词模板管理
  • Chains：将多个组件串联成工作流

优势：

  • 模块化设计，易于组合
  • 丰富的预构建组件
  • 支持多种大模型提供商
  • 活跃的社区和文档

mem0

定义：为大模型应用提供的可自我改进的记忆层框架，基于RAG架构改造而来。

在本项目中的作用：

  • 实现长期记忆的存储和检索
  • 自动从对话中提取关键信息
  • 支持语义搜索和向量检索
  • 提供多用户隔离机制

核心功能：

  • 记忆存储：将信息持久化到向量数据库
  • 记忆检索：基于语义相似度检索相关记忆
  • 记忆提取：自动从对话中提取事实信息
  • 记忆管理：支持增删改查操作

工作原理：

  1. 接收用户输入和对话历史
  2. 调用LLM提取关键事实（自动去重、合并相似记忆）
  3. 将事实转换为向量嵌入
  4. 存储到向量数据库（ChromaDB）
  5. 查询时进行语义检索（支持多模态检索）
  6. 返回相关记忆作为上下文

与传统RAG的差异：

维度 传统RAG mem0
数据来源 手动上传文档 自动从对话中提取
记忆更新 静态文档 动态学习用户偏好
检索方式 关键词匹配 语义相似度检索
用户隔离 无原生支持 内置多用户隔离机制

优势：

  • API简洁，易于集成
  • 支持多种向量数据库
  • 自动记忆提取，减少人工干预
  • 支持多用户隔离
  • 可扩展性强
  • 内置记忆去重与融合机制

ChromaDB

定义：一个开源的向量数据库，专为AI应用设计，支持语义搜索和相似度检索。

在本项目中的作用：

  • 作为mem0的向量存储后端
  • 存储记忆的向量嵌入
  • 支持高效的语义检索
  • 提供本地持久化存储

核心特性：

  • 向量存储：存储高维向量数据
  • 语义检索：基于向量相似度搜索
  • 元数据过滤：支持按元数据筛选
  • 本地优先：支持本地部署，无需云服务
  • 轻量级：易于集成和部署

工作原理：

  1. 将文本转换为向量嵌入（Embedding）
  2. 存储向量和元数据
  3. 查询时将查询文本转换为向量
  4. 计算向量相似度（如余弦相似度）
  5. 返回最相似的记录

优势：

  • 开源免费，无成本压力
  • 本地部署，数据隐私可控
  • 简单易用，快速上手
  • 支持多种嵌入模型
  • 良好的Python集成

技术栈协作关系

复制代码 
┌─────────────────────────────────────────────────────────┐
│                    应用层（Python）                     │
│  ┌──────────────┐  ┌──────────────┐  ┌─────────────┐ │
│  │ChatHistory   │  │MemoryManager │  │   Example   │ │
│  │  Manager     │  │              │  │             │ │
│  └──────┬───────┘  └──────┬───────┘  └──────┬──────┘ │
└─────────┼──────────────────┼──────────────────┼────────┘
          │                  │                  │
          │                  │                  │
┌─────────┴──────────────────┴──────────────────┴────────┐
│                  框架层（LangChain + mem0）              │
│  ┌──────────────────┐  ┌──────────────────┐           │
│  │ FileChatMessage │  │   mem0 Memory    │           │
│  │    History      │  │                  │           │
│  └────────┬─────────┘  └────────┬─────────┘           │
└───────────┼────────────────────┼───────────────────────┘
            │                    │
            │                    │
┌───────────┴────────────────────┴───────────────────────┐
│              存储层（ChromaDB + SQLite）                 │
│  ┌──────────────┐  ┌──────────────┐  ┌─────────────┐ │
│  │  ChromaDB    │  │   SQLite     │  │  JSON Files │ │
│  │  向量数据库   │  │  历史数据库   │  │  聊天历史   │ │
│  └──────────────┘  └──────────────┘  └─────────────┘ │
└──────────────────────────────────────────────────────────┘

数据流说明：

  1. 用户输入 → Python应用层
  2. 短期记忆 → LangChain的FileChatMessageHistory → JSON文件
  3. 长期记忆 → mem0 → ChromaDB向量数据库
  4. 对话历史 → mem0 → SQLite数据库
  5. 检索时 → mem0从ChromaDB检索 → 返回相关记忆

技术选型理由

技术 选型理由 适用场景
Python AI/ML领域主流语言，生态丰富 快速开发、原型验证
LangChain 提供标准化组件，降低开发复杂度 大模型应用开发
mem0 专注记忆管理，API简洁 长期记忆实现
ChromaDB 开源免费，本地部署，隐私可控 向量存储和检索

🎯 核心内容

本指南全面介绍AI应用中的记忆管理技术，涵盖：

  • 短期记忆：基于LangChain的聊天历史管理（ChatHistoryManager）
  • 长期记忆：基于mem0的持久化记忆存储（MemoryManager）
  • 记忆融合：短期与长期记忆的协同使用
  • 工程实践：完整的项目结构、配置、测试和示例

📚 一、记忆的本质：大模型如何拥有长期记忆

大模型天生是"鱼的记忆"------每次对话都是全新的开始。要让AI记住用户的偏好和历史交互，我们需要通过两种方式实现记忆：

短期记忆（Short-term Memory）

  • 将聊天历史放入提示词
  • 仅能记住"近期"内容
  • 受上下文窗口限制
  • 适合单次会话的连续对话
  • 实现方式：基于LangChain的FileChatMessageHistory

长期记忆（Long-term Memory）

  • 突破上下文窗口限制
  • 持久存储用户信息、偏好等
  • 通过检索相关内容复用
  • 适合跨会话的个性化服务
  • 实现方式：基于mem0 + ChromaDB向量数据库

二、核心问题与解决方案

🤔 核心问题
  • 大模型上下文窗口大小有限，无法承载无限历史
  • 过大上下文会导致Token成本飙升
  • 传输与计算效率低
💡 解决方案

借鉴 RAG（检索增强生成） 思路：

  • 将需记忆内容存入向量数据库（ChromaDB）
  • 生成时先检索相关内容
  • 拼接上下文给大模型
  • 解决信息存储、检索、深度挖掘问题

📁 二、项目架构：从短期到长期的记忆系统设计

复制代码 
src/mem0长期记忆/
├── chat_history_manager.py      # 短期记忆管理器
├── memory_manager.py            # 长期记忆管理器
├── memory_config.py             # mem0配置
├── example.py                   # 使用示例
├── .env                         # 环境变量配置
├── history.db                   # SQLite历史数据库
├── mem0db/                      # ChromaDB向量数据库目录
│   ├── chroma.sqlite3
│   └── [uuid]/                  # 向量数据文件
├── tests/                       # 测试目录
│   ├── __init__.py
│   ├── test_chat_history_manager.py
│   └── test_memory_manager.py
└── README.md                    # 项目说明文档

🔧 二、短期记忆实现 - ChatHistoryManager

🎯 功能概述

ChatHistoryManager为对话系统提供短期记忆能力，主要特点包括：

  • 支持按会话ID管理不同用户的聊天历史
  • 内存缓存与文件持久化相结合
  • 基于LangChain的FileChatMessageHistory
  • 会话隔离机制
  • 类封装，易于扩展

二、核心技术点

  1. 会话历史管理：使用session_id隔离不同会话
  2. 内存缓存机制：mem_store字典缓存会话历史
  3. 文件持久化存储：JSON格式存储到本地文件
  4. LangChain集成：基于BaseChatMessageHistory接口
  5. 会话隔离：每个session_id独立存储

三、代码实现

1. ChatHistoryManager类
python 复制代码 
# -*- coding: utf-8 -*-
"""
@Time    : 2025/12/14 04:33
@Author  : zuozewei
@File    : chat_history_manager.py
@Desc    : 聊天历史管理 - 基于文件持久化+内存缓存，支持多会话隔离，实现对话历史的保存、读取和管理
"""
from langchain_community.chat_message_histories import FileChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory


class ChatHistoryManager:
    """聊天历史管理器类"""

    def __init__(self):
        """初始化聊天历史管理器"""
        self.mem_store = {}

    def get_session_history(self, session_id: str) -> BaseChatMessageHistory:
        """
        获取会话历史
        :param session_id: 会话ID
        :return: 会话历史
        """
        if session_id not in self.mem_store:
            self.mem_store[session_id] = FileChatMessageHistory(
                file_path=f"./history_{session_id}.json"
            )

        return self.mem_store[session_id]

核心设计：

  • 使用类封装，避免全局变量
  • mem_store字典缓存会话历史对象
  • 首次访问时创建FileChatMessageHistory对象
  • 后续访问直接返回缓存对象
  • 文件路径格式：history_{session_id}.json

📝 使用示例

python 复制代码 
from chat_history_manager import ChatHistoryManager
from langchain_core.messages import HumanMessage, AIMessage

# 创建管理器实例
manager = ChatHistoryManager()

# 获取或创建会话历史
history = manager.get_session_history("user123")

# 添加消息
history.add_message(HumanMessage(content="你好，请问今天天气怎么样？"))
history.add_message(AIMessage(content="今天天气晴朗，温度适宜。"))

# 获取所有消息
messages = history.messages
print(f"会话历史包含 {len(messages)} 条消息")
for msg in messages:
    print(f"{msg.type}: {msg.content}")

# 清除历史记录
history.clear()

📊 运行结果

复制代码 
会话历史包含 2 条消息
human: 你好，请问今天天气怎么样？
ai: 今天天气晴朗，温度适宜。

🚀 三、长期记忆实现 - MemoryManager

🧠 mem0核心介绍

定义 ：为大模型应用提供的可自我改进的记忆层，由RAG框架改造而来，替代传统RAG，统一短期+长期记忆。

优势：

  • API简洁易懂、功能强大
  • 能满足长期记忆核心需求
  • 工程化友好
  • 支持语义检索，记忆提取精准
  • 支持多用户隔离

⚙️ mem0配置实现

1. memory_config.py - 配置管理
python 复制代码 
# -*- coding: utf-8 -*-
"""
@Time    : 2025/12/14 04:33
@Author  : zuozewei
@File    : memory_config.py
@Desc    : mem0长期记忆配置 - 基于向量存储的持久化记忆系统
"""
import os
import warnings
from dotenv import load_dotenv

load_dotenv()

api_base = os.getenv("OPENAI_BASE_URL") or os.getenv("OPENAI_API_BASE")
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["OPENAI_BASE_URL"] = api_base

from mem0 import Memory


def create_memory():
    """
    创建Memory实例
    :return: Memory实例
    """
    return Memory.from_config({
        "version": "v1.1",
        "llm": {
            "provider": "openai",
            "config": {
                "model": os.getenv("AI_MODEL", "deepseek-v3.2"),
                "temperature": 0,
                "max_tokens": 1500,
            }
        },
        "embedder": {
            "provider": "openai",
            "config": {
                "model": "text-embedding-v4"
            }
        },
        "vector_store": {
            "provider": "chroma",
            "config": {
                "collection_name": "mem0db",
                "path": "mem0db",
            }
        },
        "history_db_path": "history.db",
    })

配置说明：

  • 使用环境变量管理API密钥和模型配置
  • 支持自定义OpenAI兼容API（如DeepSeek）
  • 使用ChromaDB作为向量存储
  • SQLite存储历史记录
  • 版本：v1.1（支持图记忆）
2. 环境变量配置（.env）
bash 复制代码 
# OpenAI API配置
OPENAI_API_KEY=your_api_key_here
OPENAI_BASE_URL=https://api.openai.com/v1
AI_MODEL=gpt-4o-mini

# 或者使用DeepSeek
# OPENAI_BASE_URL=https://api.deepseek.com/v1
# AI_MODEL=deepseek-v3.2

🏗️ MemoryManager类实现

python 复制代码 
# -*- coding: utf-8 -*-
"""
@Time    : 2025/12/14 04:33
@Author  : zuozewei
@File    : memory_manager.py
@Desc    : mem0长期记忆管理 - 基于向量存储的持久化记忆系统，支持多用户隔离和个性化回复
"""
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from memory_config import create_memory


class MemoryManager:
    """记忆管理器类"""

    def __init__(self):
        """初始化记忆管理器"""
        self.mem0 = create_memory()
        api_base = os.getenv("OPENAI_BASE_URL") or os.getenv("OPENAI_API_BASE")
        self.llm = ChatOpenAI(
            model=os.getenv("AI_MODEL", "deepseek-v3.2"),
            api_key=os.getenv("OPENAI_API_KEY"),
            base_url=api_base,
            temperature=0.7
        )
        self.prompt = ChatPromptTemplate.from_messages([
            ("system", """"你现在扮演孔子的角色，尽量按照孔子的风格回复，不要出现'子曰'。
            利用提供的上下文进行个性化回复，并记住用户的偏好和以往的交互行为。
            上下文：{context}"""),
            ("user", "{input}")
        ])
        self.chain = self.prompt | self.llm

    def retrieve_context(self, query: str, user_id: str) -> str:
        """
        检索用户的上下文记忆
        :param query: 查询内容
        :param user_id: 用户ID
        :return: 上下文记忆
        """
        memories = self.mem0.search(query, user_id=user_id)
        return ' '.join([mem["memory"] for mem in memories['results']])

    def save_interaction(self, user_id: str, user_input: str, assistant_response: str):
        """
        保存用户交互记录到记忆中
        :param user_id: 用户ID
        :param user_input: 用户输入
        :param assistant_response: 助手回复
        """
        interaction = [
            {
                "role": "user",
                "content": user_input
            },
            {
                "role": "assistant",
                "content": assistant_response
            }
        ]
        self.mem0.add(interaction, user_id=user_id)

    def add_memory(self, user_id: str, memory: str, metadata: dict = None):
        """
        添加用户记忆
        :param user_id: 用户ID
        :param memory: 记忆内容
        :param metadata: 元数据（可选）
        """
        if metadata is None:
            metadata = {}
        self.mem0.add(memory, user_id=user_id, metadata=metadata)

    def search_memories(self, query: str, user_id: str) -> list:
        """
        搜索用户记忆
        :param query: 查询内容
        :param user_id: 用户ID
        :return: 记忆列表
        """
        memories = self.mem0.search(query, user_id=user_id)
        return memories['results']

    def invoke(self, user_input: str, user_id: str) -> str:
        """
        调用AI助手，自动检索上下文并保存交互
        :param user_input: 用户输入
        :param user_id: 用户ID
        :return: AI回复
        """
        context = self.retrieve_context(user_input, user_id)
        response = self.chain.invoke({
            "context": context,
            "input": user_input
        })

        content = response.content
        # 异步保存交互记录，提升响应速度
        import asyncio
        asyncio.create_task(self.save_interaction_async(user_id, user_input, content))
        return content

    async def save_interaction_async(self, user_id: str, user_input: str, assistant_response: str):
        """
        异步保存用户交互记录到记忆中
        :param user_id: 用户ID
        :param user_input: 用户输入
        :param assistant_response: 助手回复
        """
        interaction = [
            {
                "role": "user",
                "content": user_input
            },
            {
                "role": "assistant",
                "content": assistant_response
            }
        ]
        self.mem0.add(interaction, user_id=user_id)

核心方法：

  • retrieve_context(): 检索用户相关记忆
  • save_interaction(): 保存对话交互
  • add_memory(): 添加用户记忆
  • search_memories(): 搜索用户记忆
  • invoke(): 完整的AI调用流程（检索→生成→保存）

📝 使用示例

python 复制代码 
from memory_manager import MemoryManager

# 创建管理器实例
manager = MemoryManager()

# 添加记忆
manager.add_memory("dreamhead", "我喜欢读书", {"category": "hobbies"})
manager.add_memory("dreamhead", "我喜欢编程", {"category": "hobbies"})
manager.add_memory("dreamhead", "我住在上海", {"category": "location"})

# 搜索记忆
memories = manager.search_memories("dreamhead有哪些爱好？", "dreamhead")
print("搜索结果:")
for i, mem in enumerate(memories, 1):
    print(f"  {i}. {mem['memory']}")

# AI对话
response = manager.invoke("你了解我吗？", "dreamhead")
print(f"AI: {response}")

🧪 完整示例（example.py）

python 复制代码 
# -*- coding: utf-8 -*-
"""
@Time    : 2025/12/14 04:33
@Author  : zuozewei
@File    : example.py
@Desc    : 使用示例 - 展示如何使用MemoryManager和ChatHistoryManager
"""
from memory_manager import MemoryManager
from chat_history_manager import ChatHistoryManager


def main():
    """主函数 - 演示使用示例"""
    print("=== mem0长期记忆系统使用示例 ===\n")

    memory_manager = MemoryManager()
    chat_history_manager = ChatHistoryManager()

    print("1. 添加用户记忆")
    memory_manager.add_memory("dreamhead", "我喜欢读书", {"category": "hobbies"})
    memory_manager.add_memory("dreamhead", "我喜欢编程", {"category": "hobbies"})
    memory_manager.add_memory("dreamhead", "我住在上海", {"category": "location"})
    print("   已为用户 'dreamhead' 添加3条记忆\n")

    print("2. 搜索用户记忆")
    memories = memory_manager.search_memories("dreamhead有哪些爱好？", "dreamhead")
    print("   搜索结果:")
    for i, mem in enumerate(memories, 1):
        print(f"     {i}. {mem['memory']}")
    print()

    print("3. AI对话测试（孔子风格）")
    user_input = "你好，我是新来的"
    response = memory_manager.invoke(user_input, "dreamhead")
    print(f"   用户: {user_input}")
    print(f"   AI: {response}\n")

    print("4. 基于记忆的个性化回复")
    user_input = "你了解我吗？"
    response = memory_manager.invoke(user_input, "dreamhead")
    print(f"   用户: {user_input}")
    print(f"   AI: {response}\n")

    print("5. 多用户隔离测试")
    memory_manager.add_memory("alice", "我喜欢音乐", {"category": "hobbies"})
    memory_manager.add_memory("alice", "我住在北京", {"category": "location"})

    alice_memories = memory_manager.search_memories("alice有哪些爱好？", "alice")
    print(f"   Alice的爱好: {' '.join([mem['memory'] for mem in alice_memories])}")

    dreamhead_memories = memory_manager.search_memories("dreamhead有哪些爱好？", "dreamhead")
    print(f"   Dreamhead的爱好: {' '.join([mem['memory'] for mem in dreamhead_memories])}\n")

    print("6. 交互式对话测试（输入 'exit' 退出）")
    print("   提示: 你可以尝试问AI关于你的信息\n")

    user_id = "dreamhead"
    while True:
        try:
            user_input = input(f"   [{user_id}] > ")
            if user_input.lower() == 'exit':
                print("   退出对话")
                break

            response = memory_manager.invoke(user_input, user_id)
            print(f"   AI: {response}\n")
        except KeyboardInterrupt:
            print("\n   退出对话")
            break

    print("\n=== 示例完成 ===")


if __name__ == "__main__":
    main()

六、运行结果示例

复制代码 
=== mem0长期记忆系统使用示例 ===

1. 添加用户记忆
   已为用户 'dreamhead' 添加3条记忆

2. 搜索用户记忆
   搜索结果:
     1. 喜欢编程
     2. 喜欢读书
     3. 住在上海

3. AI对话测试（孔子风格）
   用户: 你好，我是新来的
   AI: （微笑）有朋自远方来，不亦乐乎。你来自何处？

4. 基于记忆的个性化回复
   用户: 你了解我吗？
   AI: （微笑）吾闻汝言，汝乃新来之客，好编程之术，喜读书之道，居于沪上。然人之性，非止于表，愿闻汝志。

5. 多用户隔离测试
   Alice的爱好: 喜欢音乐 住在北京
   Dreamhead的爱好: 喜欢编程 喜欢读书 你好，我是新来的 住在上海

6. 交互式对话测试（输入 'exit' 退出）
   提示: 你可以尝试问AI关于你的信息

   [dreamhead] > 你好，我是新来的
   AI: 善哉！汝自远方而来，当以礼相待。上海乃繁华之地，然吾闻之，繁华中亦有宁静之处。汝既好读书与编程，此二者皆需静心钻研。昔者吾尝言："学而时习之，不亦说乎？"愿汝在上海能得其所，以学问修身，以技艺立世。

   [dreamhead] > exit
   退出对话

=== 示例完成 ===

🔗 第五部分：短期与长期记忆的融合实践

一、融合架构设计

复制代码 
用户输入
    ↓
短期记忆检索（ChatHistoryManager）
    ↓
长期记忆检索（MemoryManager）
    ↓
上下文拼接
    ↓
大模型生成
    ↓
保存到短期记忆
    ↓
提取事实保存到长期记忆

二、完整实现示例

python 复制代码 
from memory_manager import MemoryManager
from chat_history_manager import ChatHistoryManager
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate


class DualMemoryManager:
    """双记忆管理器 - 融合短期和长期记忆"""

    def __init__(self):
        """初始化双记忆管理器"""
        self.memory_manager = MemoryManager()
        self.chat_history_manager = ChatHistoryManager()

    def invoke_with_dual_memory(self, user_input: str, user_id: str) -> str:
        """
        融合短期和长期记忆的调用函数
        :param user_input: 用户输入
        :param user_id: 用户ID
        :return: AI回复
        """
        # 1. 获取短期记忆（最近N条消息）
        history = self.chat_history_manager.get_session_history(user_id)
        recent_messages = history.messages[-10:]  # 最近10条
        short_term_context = "\n".join([
            f"{msg.type}: {msg.content}" for msg in recent_messages
        ])

        # 2. 获取长期记忆（相关记忆）
        long_term_memories = self.memory_manager.search_memories(user_input, user_id)
        long_term_context = "\n".join([mem['memory'] for mem in long_term_memories])

        # 3. 拼接上下文
        full_context = f"""【近期对话历史】
{short_term_context}

【长期记忆】
{long_term_context}"""

        # 4. 调用大模型生成回答
        response = self.memory_manager.invoke(user_input, user_id)

        # 5. 保存到短期记忆
        history.add_user_message(user_input)
        history.add_ai_message(response)

        return response


# 使用示例
if __name__ == "__main__":
    manager = DualMemoryManager()
    user_id = "dreamhead"

    # 先添加一些长期记忆
    manager.memory_manager.add_memory(user_id, "我喜欢读书", {"category": "hobbies"})
    manager.memory_manager.add_memory(user_id, "我喜欢编程", {"category": "hobbies"})

    # 开始对话
    while True:
        user_input = input(f"[{user_id}] > ")
        if user_input.lower() == "exit":
            break

        response = manager.invoke_with_dual_memory(user_input, user_id)
        print(f"AI: {response}")

三、融合策略建议

  1. 短期记忆策略

    • 保留最近10-20条消息
    • 超过限制时自动清理旧消息
    • 适合保持对话连贯性

  2. 长期记忆策略

    • 存储用户偏好、重要事件等
    • 定期清理过期或低价值记忆
    • 适合个性化服务

  3. 检索策略

    • 短期记忆：直接获取最近消息
    • 长期记忆：基于语义检索相关记忆
    • 两者结合：提供更全面的上下文

🧪 第六部分：测试实现

一、ChatHistoryManager测试

python 复制代码 
# -*- coding: utf-8 -*-
"""
@Time    : 2025/12/14 04:33
@Author  : zuozewei
@File    : test_chat_history_manager.py
@Desc    : chat_history_manager测试
"""
import sys
from pathlib import Path
from langchain_core.messages import HumanMessage, AIMessage

sys.path.insert(0, str(Path(__file__).parent.parent))

from chat_history_manager import ChatHistoryManager


def test_chat_history_manager():
    """测试ChatHistoryManager功能"""
    print("=== 测试ChatHistoryManager功能 ===\n")

    manager = ChatHistoryManager()

    print("1. 创建新会话 'test_session'")
    history = manager.get_session_history("test_session")
    print(f"   会话历史对象: {history}")
    print(f"   当前消息数量: {len(history.messages)}\n")

    print("2. 添加消息到会话")
    history.add_message(HumanMessage(content="你好，我是用户"))
    history.add_message(AIMessage(content="你好，我是AI助手"))
    print(f"   添加2条消息后，当前消息数量: {len(history.messages)}")
    print(f"   消息列表:")
    for i, msg in enumerate(history.messages, 1):
        print(f"     {i}. [{msg.type}]: {msg.content}")
    print()

    print("3. 获取已有会话 'test_session'")
    history2 = manager.get_session_history("test_session")
    print(f"   当前消息数量: {len(history2.messages)}")
    print(f"   消息列表:")
    for i, msg in enumerate(history2.messages, 1):
        print(f"     {i}. [{msg.type}]: {msg.content}")
    print()

    print("4. 创建另一个会话 'test_session2'")
    history3 = manager.get_session_history("test_session2")
    history3.add_message(HumanMessage(content="这是第二个会话"))
    print(f"   会话 'test_session2' 的消息数量: {len(history3.messages)}")
    print(f"   会话 'test_session' 的消息数量: {len(history.messages)}")
    print()

    print("5. 清空 'test_session2' 的消息")
    history3.clear()
    print(f"   清空后消息数量: {len(history3.messages)}")

    print("\n=== ChatHistoryManager测试完成 ===\n")


if __name__ == "__main__":
    test_chat_history_manager()

    print("\n✅ 所有测试通过！")

二、MemoryManager测试（模拟测试）

python 复制代码 
# -*- coding: utf-8 -*-
"""
@Time    : 2025/12/14 04:33
@Author  : zuozewei
@File    : test_memory_manager.py
@Desc    : memory_manager测试 - 模拟测试，验证代码逻辑
"""
import warnings
import sys
from pathlib import Path
from typing import Dict

warnings.filterwarnings("ignore")

sys.path.insert(0, str(Path(__file__).parent.parent))

from memory_manager import MemoryManager


class MockMemory:
    """模拟mem0的Memory类"""

    def __init__(self):
        self.memories = {}

    def add(self, memory: str, user_id: str, metadata: dict = None):
        """添加记忆"""
        if user_id not in self.memories:
            self.memories[user_id] = []

        self.memories[user_id].append({
            "memory": memory,
            "metadata": metadata or {}
        })

    def search(self, query: str, user_id: str) -> Dict:
        """搜索记忆"""
        if user_id not in self.memories:
            return {"results": []}

        if "所有" in query or "信息" in query:
            return {"results": self.memories[user_id]}

        results = []
        query_lower = query.lower()

        for mem in self.memories[user_id]:
            memory_lower = mem["memory"].lower()

            if "爱好" in query and ("读书" in memory_lower or "编程" in memory_lower or "音乐" in memory_lower or "运动" in memory_lower):
                results.append(mem)
            elif "住" in query and ("上海" in memory_lower or "北京" in memory_lower or "广州" in memory_lower):
                results.append(mem)
            elif "工作" in query or "工程师" in query or "教师" in query or "医生" in query:
                results.append(mem)
            elif any(keyword in memory_lower for keyword in query_lower.split() if len(keyword) > 1):
                results.append(mem)

        return {"results": results}


def test_memory_manager():
    """测试MemoryManager功能"""
    print("=== 测试MemoryManager功能 ===\n")

    manager = MemoryManager()
    mock_mem0 = MockMemory()
    manager.mem0 = mock_mem0

    print("1. 添加用户记忆")
    manager.add_memory("dreamhead", "我喜欢读书", {"category": "hobbies"})
    manager.add_memory("dreamhead", "我喜欢编程", {"category": "hobbies"})
    manager.add_memory("dreamhead", "我住在上海", {"category": "location"})
    print("   已为用户 'dreamhead' 添加3条记忆\n")

    print("2. 搜索用户记忆")
    memories = manager.search_memories("dreamhead有哪些爱好？", "dreamhead")
    print("   搜索结果:")
    for i, mem in enumerate(memories, 1):
        print(f"     {i}. {mem['memory']}")
    print()

    print("3. 多用户隔离测试")
    manager.add_memory("alice", "我喜欢音乐", {"category": "hobbies"})
    manager.add_memory("alice", "我住在北京", {"category": "location"})

    alice_memories = manager.search_memories("alice有哪些爱好？", "alice")
    print(f"   Alice的爱好: {' '.join([mem['memory'] for mem in alice_memories])}")

    dreamhead_memories = manager.search_memories("dreamhead有哪些爱好？", "dreamhead")
    print(f"   Dreamhead的爱好: {' '.join([mem['memory'] for mem in dreamhead_memories])}\n")

    print("=== MemoryManager测试完成 ===\n")


def test_integration():
    """集成测试"""
    print("=== 集成测试 ===\n")

    manager = MemoryManager()
    mock_mem0 = MockMemory()
    manager.mem0 = mock_mem0

    users = ["dreamhead", "alice", "bob"]

    user_memories = {
        "dreamhead": [
            ("我喜欢读书", {"category": "hobbies"}),
            ("我喜欢编程", {"category": "hobbies"}),
            ("我住在上海", {"category": "location"}),
            ("我是一名软件工程师", {"category": "work"}),
        ],
        "alice": [
            ("我喜欢音乐", {"category": "hobbies"}),
            ("我住在北京", {"category": "location"}),
            ("我是一名教师", {"category": "work"}),
        ],
        "bob": [
            ("我喜欢运动", {"category": "hobbies"}),
            ("我住在广州", {"category": "location"}),
            ("我是一名医生", {"category": "work"}),
        ]
    }

    print("1. 为多个用户添加记忆")
    for user_id, memories in user_memories.items():
        for memory, metadata in memories:
            manager.add_memory(user_id, memory, metadata)
        print(f"   已为用户 '{user_id}' 添加 {len(memories)} 条记忆")
    print()

    print("2. 测试记忆隔离")
    for user_id in users:
        memories = manager.search_memories(f"{user_id}的信息", user_id)
        print(f"   {user_id} 的记忆数量: {len(memories)}")
        for mem in memories:
            print(f"     - {mem['memory']}")
    print()

    print("3. 测试个性化搜索")
    queries = [
        ("dreamhead", "dreamhead有哪些爱好？"),
        ("alice", "alice住在哪里？"),
        ("bob", "bob是做什么工作的？"),
    ]

    for user_id, query in queries:
        results = manager.search_memories(query, user_id)
        print(f"   查询: {query}")
        print(f"   结果: {' '.join([mem['memory'] for mem in results])}")
    print()

    print("=== 集成测试完成 ===\n")


if __name__ == "__main__":
    test_memory_manager()
    test_integration()

    print("\n✅ 所有测试通过！")

三、运行测试

bash 复制代码 
# 运行ChatHistoryManager测试
python tests/test_chat_history_manager.py

# 运行MemoryManager测试（模拟测试，无需API密钥）
python tests/test_memory_manager.py

# 运行完整示例
python example.py

📊 第七部分：技术对比与选型

一、短期记忆 vs 长期记忆

特性 短期记忆 长期记忆
存储方式 文件（JSON） 向量数据库（ChromaDB）
访问速度 快 中等
容量限制 受上下文窗口限制 几乎无限制
检索方式 直接获取 语义检索
适用场景 单次会话对话 跨会话个性化
成本 低 较高（需Embedding）
隔离方式 session_id user_id
持久化 文件持久化 数据库持久化

二、mem0的优缺点

优点
  • API简洁，学习成本低，工程化落地快
  • 支持语义检索，记忆提取精准
  • 统一短期+长期记忆，可替代传统RAG
  • 自动从对话中提取事实
  • 支持多用户隔离
  • 支持自定义LLM和Embedding模型
缺点
  • 成本较高：每次添加信息需调用大模型提取事实，Token消耗大
  • 功能迭代快：版本更新频繁，兼容性需适配
  • 细节问题：存储聊天历史仅支持SQLite，代码需优化
  • 云平台适配待完善

三、项目特色

  1. 类封装设计：使用类而非函数，更易于扩展和维护
  2. 环境变量配置：支持灵活的API配置，兼容多种LLM
  3. 完整测试覆盖：提供模拟测试，无需API密钥即可验证逻辑
  4. 多用户隔离：完善的用户数据隔离机制
  5. 持久化存储：双重持久化（文件+数据库）
  6. 角色扮演示例：孔子风格的AI回复示例

💡 第八部分：学习建议与最佳实践

一、存储扩展建议

  1. 短期记忆扩展

    • 考虑使用Redis等缓存数据库
    • 实现分布式会话管理
    • 添加会话过期机制

  2. 长期记忆扩展

    • 扩展到其他向量数据库（Pinecone、Milvus等）
    • 实现记忆分层（重要程度、时效性）
    • 添加记忆去重和合并机制

二、性能优化建议

  1. 短期记忆优化

    • 实现消息压缩和总结
    • 使用滑动窗口管理历史
    • 异步持久化到文件

  2. 长期记忆优化

    • 批量提取事实，减少API调用
    • 缓存常用查询结果
    • 实现记忆预加载

三、安全与隐私建议

  1. 数据加密

    • 对敏感聊天内容进行加密存储
    • 使用安全的密钥管理方案
    • 实现数据脱敏

  2. 访问控制

    • 实现用户级别的数据隔离
    • 添加访问审计日志
    • 支持数据删除和导出

四、功能增强建议

  1. 历史总结

    • 实现聊天历史的自动总结功能
    • 减少上下文长度
    • 提升对话效率

  2. 多模态支持

    • 扩展支持图像、音频等多模态消息的存储
    • 实现跨模态记忆检索
    • 丰富交互方式

  3. 深度挖掘

    • 实现用户行为分析
    • 预测用户偏好
    • 提供个性化推荐

五、工程实践建议

  1. 配置管理

    • 使用环境变量管理敏感信息
    • 支持多环境配置（开发、测试、生产）
    • 提供配置验证机制

  2. 错误处理

    • 添加完善的异常处理
    • 实现重试机制
    • 提供详细的日志记录

  3. 监控告警

    • 监控API调用次数和成本
    • 跟踪记忆存储大小
    • 设置性能指标告警

📚 第九部分：相关资源

LangChain相关

mem0相关

向量数据库

其他资源

🎯 总结

  1. 记忆是大模型应用的核心能力

    • 短期记忆保持对话连贯性
    • 长期记忆实现个性化服务
    • 两者结合提供最佳用户体验

  2. 技术选型建议

    • 简单场景：使用ChatHistoryManager
    • 复杂场景：使用MemoryManager
    • 生产环境：融合短期和长期记忆

  3. 工程实践要点

    • 权衡成本与功能
    • 优化存储和检索性能
    • 重视数据安全和隐私
    • 持续迭代和优化

  4. 项目亮点

    • 完整的类封装设计
    • 灵活的配置管理
    • 完善的测试覆盖
    • 多用户隔离机制
    • 实用的示例代码

🤔 思考题

  1. 除了mem0，还有哪些长期记忆解决方案？对比其差异
  2. 如何优化mem0的Token成本？（如批量提取事实、缓存记忆等）
  3. 长期记忆的深度挖掘（如用户行为分析、偏好预测）如何实现？
  4. 如何设计记忆的过期和清理机制？
  5. 如何实现记忆的版本控制和回滚？
  6. 在大规模应用中，如何优化记忆检索性能？
  7. 如何实现跨设备的记忆同步？
  8. 如何处理记忆的隐私和合规问题？

📝 附录：快速开始

安装依赖

bash 复制代码 
pip install mem0 langchain-openai langchain-core langchain-community python-dotenv

配置环境变量

创建.env文件：

bash 复制代码 
OPENAI_API_KEY=your_api_key_here
OPENAI_BASE_URL=https://api.openai.com/v1
AI_MODEL=gpt-4o-mini

运行示例

bash 复制代码 
# 运行完整示例
python example.py

# 运行测试
python tests/test_chat_history_manager.py
python tests/test_memory_manager.py

快速使用

python 复制代码 
from memory_manager import MemoryManager

# 创建管理器
manager = MemoryManager()

# 添加记忆
manager.add_memory("user123", "我喜欢读书")

# 搜索记忆
memories = manager.search_memories("爱好", "user123")

# AI对话
response = manager.invoke("你了解我吗？", "user123")
print(response)
相关推荐
数说星榆1812 小时前
小型工厂工艺流程图制作_在线设计装配/焊接/冲压工艺流程模板
大数据·论文阅读·人工智能·流程图·论文笔记
老蒋每日coding2 小时前
AI Agent 设计模式系列（十九）—— 评估和监控模式
人工智能·设计模式
AI浩2 小时前
用于自动驾驶的ApolloScape数据集
人工智能·机器学习·自动驾驶
weixin_421585012 小时前
无监督配准
人工智能
救救孩子把2 小时前
56-机器学习与大模型开发数学教程-5-3 最速下降法与动量法（Momentum）
人工智能·机器学习
馨谙2 小时前
shell编程实际应用----磁盘空间监控与告警
linux·运维·服务器
njsgcs2 小时前
MiniCPM4-0.5B-QAT-Int4-GPTQ-format 小显存llm
linux·人工智能
Paul-LangJun2 小时前
互信息和InfoNCE的关系
人工智能·对比学习·infonce·互信息
lixin5565562 小时前
基于神经网络的音乐生成增强器
java·人工智能·pytorch·python·深度学习·语言模型
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03Claude Code Skills 实用使用手册04Open Code教程（四）| 高级配置与集成05UV安装并设置国内源06Linux下V2Ray安装配置指南07在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）08AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南09Labelme从安装到标注：零基础完整指南10Antigravity AI编程工具添加和使用Skill完整教程