AGENT

从Mem0到Mem0ᵍ: 为了不再忘却

Mem0 的独特之处在于它并没有简单地扩展上下文窗口，而是实现了一个像大脑一样运作的记忆系统。

admin

Dec 17, 2025 • 17 min read

你是否曾有过这样的经历：和 ChatGPT 聊天，聊了很久之后，它突然把所有话都忘了？比如，你一开始说自己是素食主义者，结果 20 条消息之后，它却在给你推荐最好的牛排餐厅？

是啊，我也遇到过这种情况。说实话，这不仅仅是令人恼火——这是一个根本性的问题，它阻碍了人工智能真正融入我们的日常生活。

但令人振奋的消息是：研究人员在2025年4月发表了一篇论文，或许已经破解了这个难题。这项技术名为Mem0，相信我，这绝非一次小幅改进。它是一项突破性的进展，可能会彻底改变我们与人工智能的互动方式。

让我来为你详细介绍一下这项技术的特别之处，以及为什么你应该关注它（即使你不是像我一样的技术达人😄）。

1、我们都经历过的问题

想想你上次与人工智能助手的对话。也许你在计划一次旅行，获取健康建议，或者只是集思广益。一切似乎都很顺利……直到第二天你再次使用它。

突然间，感觉就像在和一个陌生人说话。人工智能完全不记得你们之前的对话内容。你不得不重新解释一切——你的偏好、你的背景、你的目标。这就像陷入了《土拨鼠日》的循环，只不过只有你一个人记得。

以下是其背后的运作机制：

像 GPT-4、Claude 或 Gemini 这样的大型语言模型 (LLM) 使用一种叫做“上下文窗口”的东西。你可以把它想象成人工智能的短期记忆——它一次只能存储一定量的信息。对于 GPT-4 来说，这大约是 128,000 个词元（约 96,000 个单词）。听起来很多，对吧？

但问题在于：

长时间的对话会迅速填满这个空间
一旦填满，旧信息就会被挤出（就像水从杯子里溢出来一样）
每次新的聊天会话都从头开始
AI无法选择性地记住真正重要的信息

这就像每天都要和一个失忆的人谈恋爱。一点也不理想，对吧？

2、Mem0 横空出世：颠覆游戏规则

Mem0 的独特之处在于？它并没有简单地扩展上下文窗口（这只会让一切变得更慢、更耗费资源），而是 Mem0.ai 的研究人员打造了一个更智能的系统：一个像大脑一样运作的记忆系统。

最精彩之处在于：Mem0 不会试图记住所有内容。它只会提取、整合并检索真正重要的信息。

不妨这样理解：当你遇到一个陌生人时，你的大脑不会记录他们说的每一个字。相反，你会记住那些重要的信息——他们的名字、他们的籍贯、他们的爱好等等。这正是 Mem0 的工作原理。

3、两阶段魔法

Mem0 通过两个优雅的阶段在后台无缝运行：

第一阶段：提取（智能过滤）

当你与人交谈时，Mem0 不会把所有内容都一股脑地存入存储空间。它会：

分析新消息——我们刚才聊了什么？
检查对话摘要——了解更广泛的背景信息。
查看最近的消息——哪些内容与当前相关？
提取关键记忆——哪些内容真正值得记住？

以下是一个简单的代码示例，展示了其工作原理：

# This is how Mem0 processes new information
from mem0 import Memory

# Initialize the memory system
memory = Memory()
# When you have a conversation
user_message = "I'm vegetarian and allergic to dairy products"
assistant_response = "Got it! I'll remember your dietary restrictions."
# Mem0 automatically extracts and stores the important parts
memory.add(
    messages=[user_message, assistant_response],
    user_id="alice",
    metadata={
        "category": "dietary_preferences",
        "timestamp": "2025-04-15T10:30:00Z"
    }
)
# Later, when you ask for restaurant recommendations
query = "Suggest some restaurants for dinner"
relevant_memories = memory.search(query, user_id="alice")
# Mem0 retrieves: "User is vegetarian, allergic to dairy"
# And the AI can now give you perfect recommendations!

第二阶段：更新（智能组织者）

但真正巧妙之处在于，Mem0 并非随机堆积记忆。当有新信息传入时，它会：

与现有记忆进行比较——“我们已经知道一些关于这方面的信息了吗？”
做出明智的决策——我们应该添加、更新、合并还是跳过？
保持内容连贯一致——避免矛盾和冗余

这可以防止您的 AI 的内存变成杂乱无章、堆满随机信息的垃圾桶。

# Example of how Mem0 handles conflicting information

# First conversation
memory.add(
    "I love spicy food and eat it every day",
    user_id="bob"
)
# Later, user's preference changes
memory.add(
    "Actually, I've developed acid reflux, so I avoid spicy food now",
    user_id="bob"
)
# Mem0 automatically:
# 1. Detects the conflict
# 2. Updates the old memory
# 3. Timestamps the change
# 4. Maintains a coherent profile
# So when you ask about restaurants later...
memories = memory.search("food recommendations", user_id="bob")
# Result: "User previously loved spicy food, but now avoids it due to acid reflux (as of May 2025)"

4、实现此功能的架构

让我用通俗易懂的方式解释一下其中的技术奥秘：

这个系统的优点在于它是异步运行的——这意味着您的对话永远不会被中断人工智能在整理记忆的同时，就像拥有一个私人助理，在后台不断地归档重要笔记。

5、Mem0ᵍ：图驱动的升级版

如果您觉得基础版 Mem0 已经很惊艳了，那么 Mem0ᵍ（发音为“Mem0-graph”）绝对会让您眼前一亮。这才是真正精彩的部分。

研究人员并没有止步于将记忆存储为文本。他们构建了一个版本，将记忆表示为知识图谱——本质上，就是一个相互关联的事实网络。

图为什么重要？

想象一下，你正在计划一次旅行，你告诉你的 AI：

“我六月份要去东京”
“我的朋友 Sarah 住在涩谷”
“我喜欢拉面，但讨厌人多的地方”
“我想参观博物馆”

一个简单的基于文本的记忆系统会将这些信息存储为单独的事实。但 Mem0ᵍ 创建了一个知识图谱：

YOU ─[visiting]→ TOKYO
TOKYO ─[has_district]→ SHIBUYA
SARAH ─[lives_in]→ SHIBUYA
YOU ─[friend]→ SARAH
YOU ─[loves]→ RAMEN
YOU ─[prefers]→ QUIET_PLACES
YOU ─[interested_in]→ MUSEUMS

现在，当你问“莎拉附近哪里有拉面店？”时，AI 可以：

找到莎拉住在涩谷
在涩谷寻找拉面店
筛选出不太拥挤的拉面店
优先考虑靠近你可能参观的博物馆的拉面店

这就是关系记忆的力量！

6、Mem0ᵍ 的底层工作原理

基于图的方法包含两个专门的模块：

a) 实体提取器：

# Identifies entities (people, places, concepts)
entities = extract_entities("I'm meeting Sarah at the Tokyo museum tomorrow")
# Returns:
# - "Sarah" (PERSON)
# - "Tokyo" (LOCATION)
# - "museum" (PLACE)
# - "tomorrow" (TIME)

b) 关系生成器：

# Creates connections between entities
relations = generate_relations(entities, context)
# Returns triplets:
# - (YOU, meeting, Sarah)
# - (meeting, at, Tokyo_museum)
# - (meeting, time, tomorrow)

5、冲突解决器：保持记忆清晰 🔧

Mem0ᵍ 最酷的功能之一是它如何处理冲突信息。假设：

第 1 天：“Sarah 住在涩谷” 第 30 天：“Sarah 上周搬到了新宿”

系统：

检测冲突（同一个人，不同的地点）
检查时间戳
更新关系图：Sarah ─[lived_in]→ 涩谷（截至 2025 年 4 月）
添加新关系：Sarah ─[lives_in]→ 新宿（自 2025 年 4 月起）

这样，您的 AI 就能保持对不断变化的事实的准确且具有时间感知能力的理解。

# Example of graph-based memory with temporal awareness
class MemoryGraph:
    def __init__(self):
        self.nodes = {}  # Entities
        self.edges = []  # Relationships
    
    def add_relationship(self, subject, predicate, object, timestamp):
        """Add a new relationship to the graph"""
        # Check for conflicts
        existing = self.find_relationship(subject, predicate)
        
        if existing:
            # Mark old relationship as historical
            existing['valid_until'] = timestamp
            existing['status'] = 'superseded'
        
        # Add new relationship
        new_rel = {
            'subject': subject,
            'predicate': predicate,
            'object': object,
            'valid_from': timestamp,
            'status': 'active'
        }
        self.edges.append(new_rel)
    
    def query(self, subject, predicate, time=None):
        """Query the graph with temporal awareness"""
        results = []
        for edge in self.edges:
            if edge['subject'] == subject and edge['predicate'] == predicate:
                # If time specified, check validity
                if time is None or self._is_valid_at(edge, time):
                    results.append(edge)
        return results

6、令人瞩目的结果

好吧，这个架构听起来很酷，但它真的有效吗？研究人员在 LOCOMO 基准测试中测试了 Mem0——这是一项严格的测试，包含 10 个对话，每个对话平均 600 轮（每个对话约 26,000 个词元）。

数据不会说谎

以下是最让我震惊的是：

准确率提升：

比 OpenAI 的记忆系统提升 26%（LLM 作为评判标准得分分别为 66.9% 和 52.9%）
始终优于 6 种不同的基准方法
在所有问题类型中均表现出色：单跳、多跳、时间型和开放域型

速度提升：

与全上下文方法相比，延迟降低 91%
P95 延迟：1.44 秒（OpenAI 为 17.12 秒）
这意味着即使拥有数月的对话历史，您的 AI 也能几乎瞬间响应

成本节省：

每次查询所需的 token 减少 90%
约 1,800 个 token 而非 26,000 个 token
这意味着 API 使用成本大幅降低

7、按问题类型细分性能

让我向您展示 Mem0 在不同类型的问题上的表现：

单跳问题（简单回忆)

示例：“爱丽丝最喜欢的食物是什么？”
Mem0 得分：F1=38.72，Judge=67.13
优势：密集型自然语言记忆非常适合直接查找事实

多跳问题（关联信息）

示例：“爱丽丝的素食主义朋友不喜欢吃辣，他会喜欢哪家餐厅？”
Mem0 得分：F1=28.64，Judge=51.15
优势：能够高效地将多个相关的记忆串联起来

时间问题（时间感知推理）

示例：“爱丽丝搬到东京之前住在哪里？”
Mem0ᵍ 得分：Judge=55.62（比基础 Mem0 提高 2%）
优势：带有时间戳的图结构支持时间顺序推理

开放领域问题（复杂理解）

示例：“爱丽丝在过去一年中对健康的态度发生了哪些变化？”
Mem0ᵍ 得分：Judge=67.24（同类最佳）
卓越之处：图关系有助于整合随时间变化的模式

注：研究界对 LOCOMO 基准测试方法存在一些争议（Zep 团队提出了一些合理的批评），但即使调整了比较方法，Mem0 也展现出了显著的性能提升。

8、实际应用：它将改变一切

好了，理论就到此为止。让我们来谈谈它将如何影响你的生活：

8.1 真正了解你的个人 AI 助手

想象一下，一个 AI 能够记住：

你的工作安排，并且更喜欢早上开会
你的咖啡订单（燕麦奶拿铁，不加糖）
你正在备战马拉松
你孩子周四的足球比赛
你对贝类过敏

再也不用重复自己的话了。

# Real-world example: Scheduling assistant
def smart_meeting_scheduler(request, user_id):
    # Retrieve user preferences
    memories = memory.search(
        "meeting preferences schedule",
        user_id=user_id
    )
    
    # Parse remembered preferences
    prefs = {
        'preferred_time': 'morning',
        'meeting_length': 30,
        'no_meetings_thursday': True,  # Soccer games
        'buffer_time': 15  # Training runs
    }
    
    # Suggest meetings that respect ALL preferences
    suggestions = generate_meeting_times(request, prefs)
    
    return suggestions

8.2 能够记住您问题的客户支持

您是否曾经拨打技术支持电话，却不得不第三次解释您的问题？使用 Mem0：

# Customer support context
def handle_support_query(user_id, current_issue):
    # Load complete customer history
    history = memory.search(
        "previous issues tickets solutions",
        user_id=user_id
    )
    
    # AI knows:
    # - Previous issues you reported
    # - Solutions that worked (or didn't)
    # - Your preferred communication style
    # - Your technical proficiency level
    
    # Provide context-aware support
    return personalized_solution(current_issue, history)

8.3 具有连续性的医疗保健助手

跟踪以下信息的医疗 AI：

症状随时间的变化
药物反应
生活方式的改变
治疗效果

# Healthcare monitoring example
def health_check_in(user_id, today_symptoms):
    # Retrieve health history
    health_memories = memory.search(
        "symptoms medications treatments responses",
        user_id=user_id
    )
    
    # Detect patterns
    if detect_symptom_pattern(today_symptoms, health_memories):
        alert_healthcare_provider(user_id)
    
    # Track medication effectiveness
    med_response = analyze_treatment_response(health_memories)
    
    return {
        'assessment': today_symptoms,
        'trends': med_response,
        'recommendations': generate_advice(health_memories)
    }

8.4 个性化学习伙伴

能够记住以下内容的教育型人工智能：

您感到困惑的概念
您的学习进度
让您豁然开朗的例子
您之前提出的问题

告别千篇一律的教程——一切都根据您的学习历程量身定制。

9、技术实现：动手实践

想亲自尝试一下吗？让我们逐步完成整个实现过程：

步骤 1：安装和设置

# Install Mem0
pip install mem0ai

# Or use the development version
git clone https://github.com/mem0ai/mem0
cd mem0
pip install -e .

步骤 2：基本记忆操作

from mem0 import Memory
import os

# Initialize with your preferred LLM
os.environ["OPENAI_API_KEY"] = "your-api-key"
memory = Memory()
# Store a memory
result = memory.add(
    "I'm learning Python and struggling with async programming",
    user_id="student_123",
    metadata={
        "category": "learning",
        "subject": "python",
        "difficulty": "intermediate"
    }
)
print(f"Memory stored with ID: {result['id']}")
# Retrieve relevant memories
query = "Show me Python tutorials"
related_memories = memory.search(
    query=query,
    user_id="student_123",
    limit=5
)
for mem in related_memories:
    print(f"Memory: {mem['text']}")
    print(f"Relevance: {mem['score']}")

步骤 3：构建对话代理

import openai
from mem0 import Memory

class MemoryEnabledAgent:
    def __init__(self, user_id):
        self.user_id = user_id
        self.memory = Memory()
        self.client = openai.OpenAI()
    
    def chat(self, user_message):
        # Retrieve relevant memories
        context = self.memory.search(
            query=user_message,
            user_id=self.user_id,
            limit=3
        )
        
        # Build context-aware prompt
        memory_context = "\n".join([
            f"- {mem['text']}" for mem in context
        ])
        
        system_prompt = f"""You are a helpful assistant.
        You remember the following about the user:
        {memory_context}
        
        Use this context to provide personalized responses."""
        
        # Get AI response
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_message}
            ]
        )
        
        assistant_message = response.choices[0].message.content
        
        # Store the new conversation
        self.memory.add(
            f"User: {user_message}\nAssistant: {assistant_message}",
            user_id=self.user_id
        )
        
        return assistant_message
# Usage
agent = MemoryEnabledAgent(user_id="alice")
# First conversation
print(agent.chat("I'm planning to learn web development"))
# Response: "That's great! Let's start with the fundamentals..."
# Later conversation (even in a new session)
print(agent.chat("What should I learn next?"))
# Response: "Since you're learning web development, I'd recommend..." 
# (It remembers the context!)

步骤 4：图内存的高级用法

# Using graph-based memory for complex relationships
from mem0 import MemoryGraph

graph_memory = MemoryGraph(
    config={
        "graph_store": {
            "provider": "neo4j",  # Or other graph databases
            "config": {
                "url": "bolt://localhost:7687",
                "username": "neo4j",
                "password": "password"
            }
        }
    }
)
# Store with relationships
graph_memory.add(
    "Sarah is Alice's friend and lives in Tokyo",
    user_id="alice",
    metadata={"type": "relationship"}
)
# Query with graph traversal
query = "Who do I know in Tokyo?"
results = graph_memory.search(
    query=query,
    user_id="alice",
    search_type="graph"  # Use graph-based retrieval
)
# Results leverage relationship traversal
# Can answer: "Your friend Sarah lives in Tokyo"

步骤 5：生产部署注意事项

# Example production setup with error handling
class ProductionMemoryAgent:
    def __init__(self, user_id, config):
        self.user_id = user_id
        self.memory = Memory(config=config)
        self.max_retries = 3
        
    async def add_memory_with_retry(self, text, metadata=None):
        """Add memory with retry logic"""
        for attempt in range(self.max_retries):
            try:
                result = await self.memory.add_async(
                    text=text,
                    user_id=self.user_id,
                    metadata=metadata
                )
                return result
            except Exception as e:
                if attempt == self.max_retries - 1:
                    # Log error and fallback
                    logging.error(f"Memory add failed: {e}")
                    return None
                await asyncio.sleep(2 ** attempt)  # Exponential backoff
    
    async def get_memories_with_cache(self, query):
        """Retrieve memories with caching"""
        cache_key = f"mem:{self.user_id}:{hash(query)}"
        
        # Check cache first
        cached = await redis_client.get(cache_key)
        if cached:
            return json.loads(cached)
        
        # If not cached, fetch from Mem0
        memories = await self.memory.search_async(
            query=query,
            user_id=self.user_id
        )
        
        # Cache for 5 minutes
        await redis_client.setex(
            cache_key,
            300,
            json.dumps(memories)
        )
        
        return memories

10、性能优化技巧

根据我对 Mem0 的实验，以下是一些实用技巧：

10.1 数据块大小很重要

# Optimal configuration for different use cases

# For customer support (shorter interactions)
config_support = {
    "chunk_size": 512,
    "overlap": 50,
    "retrieval_k": 5
}
# For long-form content (documents, articles)
config_longform = {
    "chunk_size": 1024,
    "overlap": 100,
    "retrieval_k": 10
}

10.2 元数据丰富

# Rich metadata improves retrieval accuracy
memory.add(
    text="User prefers morning meetings",
    user_id="alice",
    metadata={
        "category": "preference",
        "subcategory": "scheduling",
        "priority": "high",
        "created_at": datetime.now().isoformat(),
        "source": "conversation",
        "verified": True
    }
)

# Then filter by metadata during search
results = memory.search(
    query="when does user prefer meetings",
    user_id="alice",
    filters={"category": "preference", "priority": "high"}
)

10.3 异步操作以扩展规模

import asyncio

async def process_multiple_users(user_messages):
    """Process memories for multiple users concurrently"""
    tasks = []
    
    for user_id, message in user_messages.items():
        task = memory.add_async(
            text=message,
            user_id=user_id
        )
        tasks.append(task)
    
    # Process all concurrently
    results = await asyncio.gather(*tasks)
    return results
# Usage
user_messages = {
    "alice": "I love Italian food",
    "bob": "I'm allergic to peanuts",
    "charlie": "I prefer video calls over phone"
}
results = asyncio.run(process_multiple_users(user_messages))

11、局限性和未来方向

坦白说，没有哪个系统是完美的。以下是当前的局限性以及未来的研究方向：

查询复杂度

多步骤推理仍然具有挑战性
例如：“爱丽丝的素食主义朋友正在备战马拉松，夏天要去东京，她会喜欢什么？”
这需要多次遍历图。

冲突解决

系统有时难以处理一些细微的冲突。
例如：“我通常避免摄入糖分”与“我今天吃了蛋糕”。
这究竟是偏好改变还是例外？

隐私问题

所有这些记忆都引发了一些重要问题
谁拥有这些记忆？
应该保留多久？
被遗忘权又该如何保障？

12、未来研究方向

分层记忆结构

模拟人类记忆：工作记忆、短期记忆、长期记忆
重要记忆的自动迁移

多模态记忆

记忆图像、音频、视频
跨模态检索

隐私保护记忆

联邦学习方法
设备端记忆处理
加密记忆存储

动态记忆巩固

随时间自动进行记忆总结
类似睡眠的记忆巩固
遗忘曲线的实现

13、结束语

Mem0 并非一篇束之高阁的研究论文。它是一个实用且可用于生产环境的解决方案，已被全球开发者广泛采用。在 GitHub 上拥有超过 43,000 个星标，并已被多家大型公司集成，这充分表明社区看到了它的潜力。

其根本转变在于从“上下文窗口”转向“持久记忆”。我们不打造会遗忘一切的人工智能，而是打造能够与您共同成长的人工智能——它能理解您的偏好，从过往互动中学习，并提供真正个性化的体验。

这种突破并非每天都能出现。更棒的是，您现在就可以开始使用它。

原文链接：How Mem0 is Revolutionizing AI Memory: The Breakthrough That Makes ChatGPT Actually Remember You…

汇智网翻译整理，转载请标明出处