1. 项目概述：当你的AI助手患上“健忘症”

你有没有遇到过这样的场景？你正在和一个AI助手进行一场深入的对话，可能是讨论一个复杂的编程问题，或者是在规划一个多步骤的创意项目。你花了十几分钟，甚至更长时间，详细地描述了背景、需求、以及之前讨论过的各种细节。然后，当你提出一个基于前面所有讨论的新问题时，AI助手却给出了一个完全跑偏、甚至自相矛盾的回答，仿佛它完全忘记了之前半小时的对话内容。这种感觉，就像和一个患有严重短期记忆障碍的伙伴合作，每一次交流都像是从零开始，让人无比沮丧。

这正是当前许多基于大语言模型（LLM）的AI应用，尤其是那些需要处理长对话或多轮复杂交互的智能体（Agent）所面临的“上下文遗忘”难题。模型的上下文窗口（Context Window）就像一块有限的黑板，当新的对话内容写上去，旧的内容就会被逐渐擦除或挤到边缘，导致模型对早期关键信息的“记忆”变得模糊甚至丢失。为了解决这个痛点，一个名为 memento-context 的项目应运而生。它不是一个全新的模型，而是一个精巧的“记忆增强”框架，旨在为你的AI智能体装上“记忆外挂”，让它能够像人类一样，在长程对话中保持对核心信息的连贯记忆与理解。

简单来说，memento-context 的核心思想是“主动记忆管理”。它不再被动地依赖模型有限的上下文窗口，而是主动地、智能地对整个对话历史进行摘要、提炼、索引和动态召回。当智能体需要回答问题时，memento-context 会像一位高效的秘书，迅速从庞大的“记忆库”中检索出最相关的历史片段，并将其精准地注入到当前的上下文提示中，从而确保AI的回答始终建立在完整的对话背景之上。接下来，我将深入拆解这个项目的设计思路、技术实现，并分享如何将其集成到你的AI应用中以解决“健忘”问题。

2. 核心设计思路：从“滑动窗口”到“记忆宫殿”

要理解 memento-context 的价值，首先得明白标准AI对话的“记忆”机制为何失效。

2.1 传统上下文管理的瓶颈

目前，绝大多数LLM应用采用一种称为“滑动窗口”的上下文管理策略。假设模型的上下文长度是4096个token（约3000字），那么系统会保留最近4096个token的对话内容作为上下文。当新的对话产生，旧的token就会被从窗口前端“挤出去”。这种机制存在几个致命缺陷：

1. 关键信息丢失 ：早期对话中的核心设定（如项目目标、用户偏好、技术栈选择）可能因为超出窗口而被遗忘。
2. 信息稀释 ：随着对话轮次增加，真正重要的信息在上下文中占比越来越小，被大量中间过程对话所稀释，模型难以聚焦。
3. Token浪费 ：每一轮对话，无论重要与否，都占用相同的token资源。重复的问候语、确认语句等冗余信息挤占了宝贵空间。
4. 无法进行长期引用 ：当用户说“按照我们一开始讨论的方案A来修改”，如果“方案A”的详细定义已在窗口之外，模型将无法正确理解。

这就像只用一块固定大小的便签纸记录整个会议纪要，会议越长，你不得不不断擦掉前面的内容来写新的，最终只记得最近几分钟的讨论。

2.2 memento-context 的“记忆宫殿”架构

memento-context 借鉴了人类构建“记忆宫殿”的方法，设计了一套分层、动态的记忆系统。其核心架构围绕以下几个关键组件展开：

1. 记忆存储器（Memory Store） ：这是一个独立于模型上下文窗口的外部存储，可以是向量数据库（如Chroma, Pinecone）、关系型数据库或简单的文件系统。它永久保存所有对话历史的“记忆痕迹”。
2. 记忆编码器（Memory Encoder） ：负责将一段对话文本（或对话中的某个片段）转化为一种可被高效检索的格式。通常，这涉及使用嵌入模型（Embedding Model）将文本转换为高维向量（向量化）。这个向量捕捉了文本的语义信息。
3. 记忆索引与检索器（Indexer & Retriever） ：对存储的记忆向量建立索引（例如使用FAISS或HNSW算法），以便进行快速的相似性搜索。当新问题到来时，检索器会计算问题与所有记忆的相似度，返回最相关的Top-K个记忆片段。
4. 记忆摘要与提炼器（Summarizer & Refiner） ：并非所有对话都值得原样保存。这个组件负责对长对话进行压缩，生成简洁的摘要，或者识别并提取出其中的关键实体、决策和事实，形成结构化的“记忆核”，从而大幅节省存储空间并提升检索质量。
5. 上下文组装器（Context Assembler） ：这是执行召回动作的组件。它根据当前用户查询，从记忆存储器中检索出相关记忆，然后将这些记忆片段与当前最新的几条对话（作为短期记忆）巧妙地组合成一个新的、信息丰富的提示（Prompt），再发送给LLM生成回答。

这套流程的核心优势在于 按需、精准地使用上下文 。它不再试图把所有东西都塞进有限的窗口，而是建立一个外部知识库，并学会在需要时快速查找。这类似于我们人类：我们不会在思考每个问题时都在脑海中复述一生所有经历，但当需要时，我们可以通过联想和回忆调取相关的特定经历。

注意 ：memento-context 的实现并非一定要包含所有上述组件。它是一个概念框架，你可以根据应用复杂度和资源情况，选择实现其中部分功能。例如，一个轻量级版本可能只包含基础的向量存储和检索。

3. 关键技术点拆解与选型

实现一个健壮的 memento-context 系统，需要在以下几个技术环节做出合适的选择。

3.1 记忆的向量化：嵌入模型的选择

将文本转化为向量是检索的基础。选择嵌入模型时，需要考虑：

• 语义理解能力 ：模型能否准确捕捉短语、句子乃至段落的深层含义？例如，“我喜欢苹果”和“我有一部iPhone”中的“苹果”应被区分开。
• 上下文长度 ：模型能处理多长的文本作为输入？对于需要记忆长段落的应用，需要支持长上下文的嵌入模型（如 text-embedding-3-large ）。
• 速度与成本 ：本地小模型（如 all-MiniLM-L6-v2 ）速度快、零成本，但能力可能较弱。云API模型（如OpenAI的Embeddings）能力更强，但会产生费用和网络延迟。
• 多语言支持 ：如果你的应用面向多语言用户，需要选择如 paraphrase-multilingual-MiniLM-L12-v2 这类模型。

实操建议 ：对于大多数应用，可以从轻量级的 all-MiniLM-L6-v2 开始。它只有80MB左右，在CPU上也能快速运行，对于初步验证概念和中等规模数据足够用。如果对精度要求高，再考虑升级到更大的模型或使用API服务。

3.2 记忆的存储与检索：向量数据库实战

向量数据库负责高效存储和检索向量。以下是几种常见方案：

• 轻量级/内置方案 ：使用 FAISS (Facebook AI Similarity Search) 库。它是一个高效的相似性搜索库，可以直接在内存或本地磁盘运行，非常适合中小规模、单机部署的场景。 Chroma 也是一个流行的轻量级选择，它提供了更友好的API和持久化存储。
• 云原生/大规模方案 ：如果需要处理亿级向量、高并发查询或分布式部署，可以考虑 Pinecone 、 Weaviate 、 Qdrant 等专业的向量数据库服务。它们提供了托管服务，简化了运维，但通常有费用。
• 传统数据库扩展 ： PostgreSQL 的 pgvector 扩展允许在关系型数据库中直接进行向量运算。这适合那些已经使用PostgreSQL，且希望将结构化数据和向量数据统一管理的场景。

配置核心参数 ：

• 索引类型 ：在FAISS中， IndexFlatL2 （精确搜索）简单但慢； IndexIVFFlat 或 IndexHNSWFlat （近似搜索）更快，适合大规模数据。HNSW通常是速度和精度平衡较好的选择。
• 检索数量K ：每次检索返回多少个记忆片段？这需要权衡。K太小可能遗漏关键信息，K太大会增加上下文长度和混淆模型。通常从3-5开始测试。
• 相似度阈值 ：可以设置一个最低相似度分数（如余弦相似度>0.7），低于此阈值的记忆被认为不相关，不予返回。这能有效过滤噪声。

3.3 记忆的提炼：从原始对话到核心记忆

原封不动地存储每一句对话是低效的。memento-context 的精髓在于“提炼”。这里有几个策略：

1. 定期摘要 ：每对话N轮，或当检测到话题明显转换时，触发一次摘要。使用LLM（可以是同一个主模型，也可以是一个更小的专用模型）将最近的对话历史总结成一段简洁的文字。这段摘要作为一条新的“记忆”存入向量库，替代或补充原始的冗长对话。
2. 关键信息提取 ：使用命名实体识别（NER）或信息抽取模型，从对话中提取出关键实体（人名、项目名、日期、技术名词）、决策点（“我们决定采用方案B”）、待办事项（“需要联系张三获取API密钥”）等，并将其结构化存储。这种结构化记忆更易于精确查询。
3. 基于重要性的记忆 ：为每段记忆赋予一个“重要性”分数。这个分数可以通过规则（如包含关键词、用户明确标记“记住这个”）、或通过一个小型模型来预测。在组装上下文时，优先纳入高分记忆。

一个简单的摘要提示词示例 ：

请将以下对话历史总结成一段不超过150字的连贯摘要，重点保留：
1. 讨论的核心主题或目标。
2. 已达成的一致结论或关键决策。
3. 下一步行动计划或待解决的问题。

对话历史：
{history}

摘要：

3.4 上下文的动态组装：提示工程的艺术

检索到相关记忆后，如何将它们与当前对话一起呈现给LLM，是一门艺术。糟糕的组装方式会让模型感到困惑。

基本组装模式 ：

你是一个有帮助的AI助手。以下是本次对话中你需要记住的背景信息（长期记忆）：
<memory_separator>
{memory_1}
{memory_2}
...
</memory_separator>

以下是最近的对话（短期记忆）：
{recent_conversation}

当前用户问题：{current_query}

请基于以上所有信息，回答用户问题。

高级技巧 ：

• 记忆排序 ：按时间顺序（最旧或最新优先）或按相关性分数排序记忆片段。
• 记忆去重 ：在注入前，对检索到的记忆进行去重，避免相同信息重复出现。
• 长度控制 ：设定一个总token上限。按照记忆的相关性分数从高到低注入，直到达到上限。
• 元信息标注 ：为每段记忆加上时间戳或来源标签，例如 [记忆来自 2023-10-27 的讨论：关于项目架构] ，帮助模型理解记忆的时效性和上下文。

4. 集成与实操：为你的AI智能体注入记忆

现在，我们来看如何将 memento-context 集成到一个实际的AI智能体项目中。假设我们正在构建一个代码助手智能体。

4.1 环境准备与基础架构

首先，定义核心的数据结构和流程。

# memory_structures.py
from pydantic import BaseModel
from datetime import datetime
from typing import List, Optional
import numpy as np

class MemoryFragment(BaseModel):
    """一个记忆片段的数据结构"""
    id: str
    content: str  # 记忆的文本内容
    embedding: Optional[np.ndarray] = None  # 向量表示
    timestamp: datetime
    importance: float = 1.0  # 重要性权重
    metadata: dict = {}  # 可存放来源、类型等元数据

class MemoryStore:
    """记忆存储的抽象接口"""
    def add_memory(self, memory: MemoryFragment):
        raise NotImplementedError

    def search_memories(self, query_embedding: np.ndarray, top_k: int = 5) -> List[MemoryFragment]:
        raise NotImplementedError

    def summarize_and_compact(self, fragment_ids: List[str]) -> Optional[MemoryFragment]:
        """对一组记忆进行摘要压缩"""
        raise NotImplementedError

4.2 实现一个基于FAISS的轻量级存储

# faiss_memory_store.py
import faiss
import pickle
import numpy as np
from pathlib import Path
from .memory_structures import MemoryStore, MemoryFragment

class FaissMemoryStore(MemoryStore):
    def __init__(self, embedding_dim: int = 384, index_path: str = "./memory_index.faiss"):
        self.embedding_dim = embedding_dim
        self.index_path = Path(index_path)
        self.metadata_path = self.index_path.with_suffix('.pkl')

        # 初始化FAISS索引 (使用L2距离，也可以选内积IP)
        self.index = faiss.IndexFlatL2(embedding_dim)
        self.memories: List[MemoryFragment] = []

        self._load_from_disk()

    def _load_from_disk(self):
        """从磁盘加载已有的索引和记忆元数据"""
        if self.index_path.exists() and self.metadata_path.exists():
            self.index = faiss.read_index(str(self.index_path))
            with open(self.metadata_path, 'rb') as f:
                self.memories = pickle.load(f)
            print(f"已加载 {len(self.memories)} 条记忆。")
        else:
            print("未找到已有记忆库，创建新库。")

    def _save_to_disk(self):
        """保存索引和记忆元数据到磁盘"""
        faiss.write_index(self.index, str(self.index_path))
        with open(self.metadata_path, 'wb') as f:
            pickle.dump(self.memories, f)

    def add_memory(self, memory: MemoryFragment):
        if memory.embedding is None:
            raise ValueError("MemoryFragment must have an embedding before adding.")
        if len(memory.embedding) != self.embedding_dim:
            raise ValueError(f"Embedding dimension mismatch. Expected {self.embedding_dim}, got {len(memory.embedding)}")

        # 添加到FAISS索引
        self.index.add(np.array([memory.embedding], dtype='float32'))
        # 添加到内存列表
        memory.id = str(len(self.memories))  # 简单ID分配
        self.memories.append(memory)
        # 持久化
        self._save_to_disk()

    def search_memories(self, query_embedding: np.ndarray, top_k: int = 5) -> List[MemoryFragment]:
        query_embedding = np.array([query_embedding], dtype='float32')
        distances, indices = self.index.search(query_embedding, top_k)

        results = []
        for idx, dist in zip(indices[0], distances[0]):
            if idx != -1 and idx < len(self.memories):  # FAISS可能返回-1
                # 可以在这里根据距离进行过滤，例如 dist < 1.0
                results.append(self.memories[idx])
        return results

    def summarize_and_compact(self, fragment_ids: List[str]):
        # 这是一个高级功能，需要调用LLM进行摘要
        # 此处简化：仅返回一个提示，实际项目需集成LLM调用
        target_fragments = [m for m in self.memories if m.id in fragment_ids]
        if not target_fragments:
            return None
        # 模拟摘要：简单拼接
        summary_content = "摘要自相关记忆：\n" + "\n".join([f.content[:100] for f in target_fragments])
        # 创建新的记忆片段（实际应用中需要生成新的embedding）
        new_memory = MemoryFragment(
            id=f"summary_{datetime.now().timestamp()}",
            content=summary_content,
            timestamp=datetime.now()
        )
        # 可选：删除或标记旧的片段
        return new_memory

4.3 构建记忆管理流程

# memento_manager.py
from sentence_transformers import SentenceTransformer
from .faiss_memory_store import FaissMemoryStore
from .memory_structures import MemoryFragment
import numpy as np

class MementoContextManager:
    def __init__(self, embedding_model_name='all-MiniLM-L6-v2'):
        self.embedder = SentenceTransformer(embedding_model_name)
        self.embedding_dim = self.embedder.get_sentence_embedding_dimension()
        self.memory_store = FaissMemoryStore(embedding_dim=self.embedding_dim)
        self.conversation_buffer = []  # 短期对话缓冲

    def add_conversation_turn(self, user_input: str, ai_response: str):
        """添加一轮对话到缓冲，并决定是否生成记忆"""
        turn_text = f"用户：{user_input}\n助手：{ai_response}"
        self.conversation_buffer.append(turn_text)

        # 策略1：每3轮对话或检测到话题结束时，生成一个记忆点
        if len(self.conversation_buffer) >= 3 or self._is_topic_shift(user_input):
            self._create_memory_from_buffer()

    def _is_topic_shift(self, current_input: str) -> bool:
        """简单的主题转移检测（示例）"""
        # 这里可以实现更复杂的逻辑，例如用embedding计算与上一轮输入的相似度
        shift_keywords = ["另外", "下一个话题", "我们换个角度", "之前说的"]
        return any(keyword in current_input for keyword in shift_keywords)

    def _create_memory_from_buffer(self):
        """将缓冲区的对话转化为记忆并存储"""
        if not self.conversation_buffer:
            return

        combined_text = "\n".join(self.conversation_buffer[-3:])  # 取最近3轮
        embedding = self.embedder.encode(combined_text)
        memory = MemoryFragment(
            content=combined_text,
            embedding=embedding,
            timestamp=datetime.now(),
            importance=1.0,
            metadata={"type": "conversation_chunk"}
        )
        self.memory_store.add_memory(memory)
        print(f"已创建记忆片段：{memory.id}")
        # 清空缓冲（或保留最近1轮作为衔接）
        self.conversation_buffer = self.conversation_buffer[-1:]

    def retrieve_relevant_context(self, query: str, top_k: int = 3) -> str:
        """根据查询检索相关记忆，并格式化为上下文字符串"""
        query_embedding = self.embedder.encode(query)
        relevant_memories = self.memory_store.search_memories(query_embedding, top_k=top_k)

        if not relevant_memories:
            return ""

        context_parts = ["【相关背景记忆】"]
        for i, mem in enumerate(relevant_memories):
            # 可以在这里截断过长的记忆内容
            context_parts.append(f"{i+1}. {mem.content[:500]}...")  # 限制长度
        return "\n".join(context_parts)

    def format_full_prompt(self, user_query: str, recent_chat: List[str]) -> str:
        """组装完整的提示词"""
        long_term_context = self.retrieve_relevant_context(user_query)
        short_term_context = "\n".join(recent_chat[-5:])  # 最近5轮短期记忆

        prompt_template = """
你是一个智能编程助手。请基于以下所有背景信息进行回答。

{long_term_context}

最近的对话：
{short_term_context}

当前用户问题：{user_query}

请给出专业、准确的回答。
"""
        return prompt_template.format(
            long_term_context=long_term_context,
            short_term_context=short_term_context,
            user_query=user_query
        )

4.4 与主流AI框架集成示例

假设你使用 LangChain 来构建智能体，集成将非常顺畅。

from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from .memento_manager import MementoContextManager

# 初始化组件
llm = OpenAI(temperature=0, model_name="gpt-3.5-turbo-instruct")
memento_manager = MementoContextManager()

# 定义主处理循环
def chat_cycle(user_input: str, chat_history: list):
    # 1. 用用户输入检索相关记忆，组装提示
    full_prompt = memento_manager.format_full_prompt(user_input, chat_history)

    # 2. 调用LLM获取回答
    response = llm(full_prompt)

    # 3. 将本轮对话添加到记忆管理器的缓冲区
    memento_manager.add_conversation_turn(user_input, response)

    # 4. 更新聊天历史（用于短期上下文）
    chat_history.append(f"用户：{user_input}")
    chat_history.append(f"助手：{response}")

    return response

# 模拟对话
history = []
print(chat_cycle("我们正在开发一个Python Web项目，决定使用FastAPI框架。", history))
print(chat_cycle("数据库方面，我打算用PostgreSQL。", history))
# ... 经过多轮对话后
print(chat_cycle("我们之前定好的Web框架是什么来着？", history))
# 此时，memento-context 应能检索到关于FastAPI的记忆，并注入上下文，使LLM正确回答。

5. 性能优化与高级策略

基础版本搭建完成后，可以考虑以下优化点来提升记忆系统的效果和效率。

5.1 记忆的更新与遗忘机制

记忆不是一成不变的。无效或过时的信息应该被清理或降权。

• 基于时间的衰减 ：为记忆的重要性权重引入衰减因子。例如，每过一天，重要性乘以0.95。在检索时，将相似度分数与衰减后的重要性权重结合排序。
• 主动遗忘 ：当用户明确说“忘记我刚才说的X”或检测到信息矛盾时（新记忆与旧记忆冲突），可以手动删除或标记旧记忆。
• 记忆合并 ：当关于同一主题的记忆片段过多时（例如，多次讨论“用户偏好”），触发一个合并任务，使用LLM将这些片段合成一个更精炼、更全面的记忆。

5.2 检索质量的提升：重排序与混合搜索

简单的向量相似度搜索有时会返回相关但不精确的结果。可以采用“多路召回+重排序”策略。

1. 混合检索 ：
   • 向量检索 ：基于语义相似度。
   • 关键词检索 ：使用BM25等传统算法，召回包含精确关键词的记忆。这对于查找特定名称、错误代码等非常有效。
   • 元数据过滤 ：例如，只检索特定类型（“决策”、“代码片段”）或特定时间段的记忆。
2. 重排序 ：将上述多种方法召回的结果混合后，使用一个更精细的“交叉编码器”模型对候选记忆进行重新打分。交叉编码器同时接收查询和候选记忆文本，能进行更深度的语义匹配判断，虽然比向量检索慢，但精度更高。可以只对Top-N的候选进行重排，平衡速度与精度。

5.3 处理超长对话与记忆爆炸

对于持续数天甚至数周的对话，记忆库可能变得非常庞大。

• 分层记忆结构 ：建立会话级、主题级、项目级等多层记忆。会话级记忆保存细节，主题级记忆保存摘要，项目级记忆保存核心目标和最终成果。检索时优先搜索高层级记忆。
• 记忆聚类与索引 ：定期对记忆进行聚类分析（如使用K-means），将相似记忆归类。检索时先找到相关聚类，再在聚类内搜索，提高效率。
• 外部知识库集成 ：对于一些通用、静态的知识（如公司文档、API手册），不应作为对话记忆存储，而应接入专门的外部知识库检索（RAG）。memento-context 应专注于存储对话中产生的、个性化的、动态的信息。

6. 常见问题与实战避坑指南

在实际部署 memento-context 时，你可能会遇到以下典型问题。

6.1 记忆检索不准确或召回无关内容

症状 ：AI的回答引用了不相关甚至错误的“记忆”，导致回答混乱。 排查与解决 ：

1. 检查嵌入模型 ：你的嵌入模型是否适合你的领域？尝试在领域相关的文本对上测试其相似度计算是否合理。对于专业领域（如法律、医疗），可能需要微调嵌入模型。
2. 调整检索参数 ：
   • 降低 top_k ：减少返回的记忆数量，可能噪声更少。
   • 设置相似度阈值 ：过滤掉低分记忆。可以动态调整阈值，例如只返回相似度高于平均分的记忆。
   • 尝试不同的距离度量 ：FAISS中，L2距离和内积（IP）适用于不同的嵌入模型。确保与模型训练时使用的度量一致（通常cosine相似度对应归一化后的内积）。
3. 优化记忆内容 ：存储的记忆片段是否过于冗长或模糊？尝试在存储前对对话进行更精细的摘要，只保留核心事实和决策。
4. 引入重排序 ：如前所述，加入一个轻量级的交叉编码器进行重排序，能显著提升Top-1的准确率。

6.2 上下文过长导致API调用费用激增或响应变慢

症状 ：每次提示词都极其冗长，LLM处理变慢，且如果使用按Token计费的API，成本不可控。 解决策略 ：

1. 记忆摘要压缩 ：这是最有效的方法。确保你的摘要器能生成高度凝练的文本。
2. 动态上下文窗口 ：为不同类型的记忆设定不同的“注入预算”。例如，核心决策记忆最多注入500 token，普通对话记忆最多200 token。在组装时，按优先级分配预算。
3. Token计数与截断 ：在组装提示词时实时计算Token数（使用 tiktoken 等库），当接近模型上限时，优先截断相关性最低的记忆内容，或对长记忆进行二次摘要。
4. 使用支持更长上下文的模型 ：如果成本允许，升级到如 gpt-4-turbo 或 claude-3 等支持128K甚至更长上下文的模型，为记忆提供更大空间。

6.3 记忆冲突与信息不一致

症状 ：关于同一件事，记忆库中存在多条内容矛盾的信息。 处理方案 ：

1. 时间戳优先 ：在检索和组装时，默认采用最新记忆。可以在记忆内容前加上“（根据最新讨论）”。
2. 冲突检测与解决 ：在添加新记忆时，计算其与已有记忆的相似度。如果相似度高但语义矛盾（可通过一个小型分类器或基于LLM的判断），则触发冲突解决流程：例如，提示用户确认，或自动基于时间戳和来源可信度进行裁决。
3. 结构化记忆 ：尽可能将记忆以结构化形式存储（如属性-值对）。当更新某个属性时，直接覆盖旧值，避免自由文本带来的歧义。

6.4 系统资源与延迟开销

症状 ：每次对话都进行向量编码和检索，导致响应延迟明显增加。 优化建议 ：

1. 异步处理 ：将记忆的编码和存储操作放到后台异步任务中，不阻塞主对话流程。用户发出消息后，立即用现有记忆检索并生成回答；同时，后台任务处理本轮对话的记忆化存储。
2. 缓存检索结果 ：对于相似的用户查询，可以缓存其检索到的记忆片段，短时间内直接复用，避免重复计算。
3. 轻量级嵌入模型 ：在边缘设备或资源受限环境中，使用更小的模型（如 all-MiniLM-L6-v2 已足够轻量）。也可以考虑量化技术进一步压缩模型。
4. 定期批处理 ：不必每轮对话都触发记忆存储。可以积累一定轮次后，批量进行摘要、编码和存储，提高效率。

为你的AI智能体集成 memento-context，本质上是在教它如何更聪明地“做笔记”和“翻笔记”。这需要一些前期设计和调试，但一旦运行起来，它将彻底改变长对话的体验。用户不再需要反复重申需求，智能体真正做到了“心中有数”，对话的深度和连续性得以大幅提升。从简单的FAISS本地存储开始，逐步根据需求引入摘要、重排序、分层记忆等高级特性，你会发现，一个拥有持久记忆的AI伙伴，其协作效率是截然不同的。