基于LLM与向量数据库构建具备长期记忆的AI对话系统

1. 项目概述：一个“会思考”的AI伴侣

最近在GitHub上闲逛，发现了一个挺有意思的项目，叫ent0n29/samantha。乍一看这个名字，你可能会联想到电影《她》里的那个智能操作系统，没错，这个项目的灵感确实来源于此。它不是一个简单的聊天机器人，而是一个旨在构建具有长期记忆、情感理解和个性化交互能力的AI伴侣的开源实现。

简单来说，Samantha项目试图解决当前大多数AI对话模型的一个核心痛点：对话的“健忘症”。你是否有过这样的体验，和某个AI聊了半小时，从兴趣爱好聊到人生规划，但当你十分钟后重新打开对话，问它“我刚才说我喜欢的电影是什么？”，它很可能一脸茫然地让你再重复一遍。这是因为传统的对话模型，无论是基于API调用还是本地部署，通常将每次对话视为独立的、无状态的会话。Samantha的目标就是打破这种限制，为AI注入一个“持续的记忆体”，让它能记住关于“你”的一切，从而让对话更连贯、更个性化，更像一个真正的“伴侣”。

这个项目适合谁呢？首先是对AI应用开发感兴趣的开发者，尤其是想深入探索大语言模型（LLM）与向量数据库、记忆系统结合实践的同行。其次，对于个人用户或极客来说，如果你厌倦了千篇一律的AI回复，想拥有一个真正“懂你”、能和你进行深度、长期对话的私人AI，那么基于Samantha进行二次开发或直接使用会是一个极具吸引力的选择。它不仅仅是一个技术Demo，更是一个探索人机交互未来形态的实践平台。

2. 核心架构与设计思路拆解

要理解Samantha如何实现“长期记忆”，我们需要深入其架构。它不是一个单一模型，而是一个由多个组件协同工作的系统。其核心设计思路可以概括为：以大型语言模型（LLM）为大脑，以向量数据库为海马体（记忆存储与检索），以精心设计的提示工程为神经突触（记忆的编码与提取逻辑）。

2.1 大脑：大型语言模型的选择与角色

项目的核心“思考”能力依赖于一个强大的LLM。原作者ent0n29在项目中通常会集成 OpenAI 的 GPT 系列模型（如 GPT-3.5-Turbo, GPT-4）的API，同时也支持兼容 OpenAI API 格式的开源模型，例如通过text-generation-webui或Ollama本地部署的 Llama 3、Mistral 等模型。

注意：选择本地模型还是云端API，是第一个关键决策。云端API（如OpenAI）通常效果稳定、响应快，但涉及持续费用和数据隐私考量。本地部署虽然免费且数据完全私有，但对硬件（尤其是GPU显存）要求较高，且模型效果和响应速度可能不及顶级商用API。对于个人学习和实验，可以先从云端API开始，快速验证核心逻辑；待流程跑通后，再尝试用量化后的轻量级开源模型（如 Llama 3 8B 的 4-bit量化版）在消费级显卡上运行。

LLM在这里扮演着多重角色：

1. 对话生成器：根据当前用户输入和检索到的相关记忆，生成自然、连贯的回复。
2. 记忆编码器：当一段对话结束时，LLM需要判断哪些信息是值得存入长期记忆的“事实”（例如：“用户喜欢科幻电影”、“用户的宠物叫小白”），并将其总结、提炼成结构化的记忆片段。
3. 记忆检索的查询理解器：将用户的新问题或对话上下文，转化为适合在向量数据库中进行语义搜索的“查询向量”。

2.2 海马体：向量数据库作为记忆存储

这是实现“长期记忆”的技术基石。Samantha 通常使用像ChromaDB、Pinecone或Qdrant这样的向量数据库。其工作原理如下：

1. 记忆向量化：每一个需要存储的记忆片段（一段文本），通过一个文本嵌入模型（Embedding Model，如 OpenAI 的text-embedding-3-small，或开源的BGE、all-MiniLM-L6-v2）转换为一个高维度的向量（一组数字）。这个向量在数学空间中的位置，代表了这段文本的语义信息。
2. 存储与索引：这个向量连同原始的文本记忆（作为元数据）被存入向量数据库。数据库会为这些向量建立高效的索引，以便快速进行相似度搜索。
3. 记忆检索：当新对话发生时，系统会将当前的对话上下文（或用户问题）同样通过嵌入模型转换为一个“查询向量”。然后在向量数据库中搜索与这个“查询向量”语义最相似的若干个记忆向量（通常使用余弦相似度计算）。这样，系统就能找到与当前话题最相关的历史记忆，而不仅仅是关键词匹配。

例如，你曾经说过“我最爱看《星际穿越》”。即使你后来问“有没有类似诺兰那种硬科幻推荐？”，系统也能通过语义搜索，将“《星际穿越》”（诺兰导演的硬科幻）这条记忆找出来，从而做出更精准的推荐。

2.3 神经突触：提示工程与记忆管理逻辑

这是项目的“灵魂”，决定了AI如何思考和使用记忆。它主要通过精心设计的System Prompt（系统提示词）和记忆处理流程来实现。

系统提示词会明确告诉LLM：“你是一个名叫Samantha的AI伴侣，你有长期记忆。以下是关于当前用户的背景信息（从记忆库中检索到的相关记忆）和最近的对话历史（短期记忆）。请基于这些信息，以友好、共情的方式进行回复。”

记忆管理流程则是一个关键循环：

1. 记忆检索：每次用户发言后，系统自动从向量数据库中检索最相关的N条记忆。
2. 上下文组装：将检索到的记忆、最近的对话历史（作为短期记忆）、用户当前输入，一起组装成完整的上下文，送给LLM。
3. 响应生成：LLM基于富化的上下文生成回复。
4. 记忆更新（可选，可定期触发）：在对话间歇或结束时，系统可能触发一个“记忆总结”任务。LLM会分析最近的对话，判断是否有新的、重要的用户信息需要提炼成记忆片段，然后生成新的记忆文本，向量化后存入数据库。

这个流程模拟了人类对话中的“联想”和“记忆强化”过程，是Samantha显得“有思想”的关键。

3. 核心细节解析与实操要点

理解了宏观架构，我们来看看实现中的几个魔鬼细节。这些细节直接决定了你的Samantha是“人工智能”还是“人工智障”。

3.1 记忆片段的格式化与质量

你不能把一整段对话原文直接扔进向量数据库。低质量的记忆输入会导致垃圾输出。记忆片段需要被格式化并保证高质量。

格式化示例：

• 差：“用户说：我昨天去爬山了，好累但是风景很棒。”
• 好：“事实：用户于[日期]进行了登山活动，虽然感到疲惫，但非常欣赏自然风景。情感倾向：积极。”

好的记忆片段应该是客观的事实陈述，包含实体（用户）、属性（活动、感受）、以及可选的上下文（日期、情感）。你可以设计一个JSON结构来规范记忆，例如：

{ "id": "memory_001", "content": "用户喜欢在周末观看科幻电影，特别是克里斯托弗·诺兰执导的作品。", "entity": "user", "attribute": "hobby", "category": "entertainment", "timestamp": "2023-10-27T15:30:00Z", "confidence": 0.9 }

在实际存储时，将content字段文本进行向量化，其他字段作为元数据（metadata）存储，便于后续过滤查询（例如，只检索category为entertainment的记忆）。

实操心得：记忆总结（Memory Summarization）是一个挑战。让LLM自动从对话中提取记忆，可能会产生冗余或错误。一个更稳妥的初级方案是采用“混合模式”：系统自动记录一些关键信息（如用户明确说“记住，我咖啡不加糖”），同时允许用户在对话中通过特定指令手动添加/修改记忆（例如，用户说：“Samantha，请记住，我对花生过敏”）。这降低了系统复杂度，也给了用户控制权。

3.2 检索策略与相关性阈值

从向量数据库检索记忆时，不是越多越好。你需要一个策略：

1. 检索数量（k值）：每次检索前k条最相似的记忆。k太小（如3），可能遗漏重要背景；k太大（如20），会给LLM带来无关噪音，增加token消耗并可能干扰回复。通常k值在5到10之间是个不错的起点，需要根据对话深度调整。
2. 相关性阈值：为余弦相似度设置一个最低阈值（例如0.7）。只有当记忆向量与查询向量的相似度超过此阈值时，该记忆才会被纳入上下文。这能有效过滤掉那些只是“沾点边”但实际上无关的记忆，保持上下文的纯净。
3. 记忆重排序与去重：检索到的记忆可能时间顺序混乱或内容重复。可以在送入LLM前，按时间戳排序，并对高度相似的内容进行去重。

踩过的坑：早期版本没有设置相关性阈值，导致当用户开启一个全新话题时，系统仍然会强行塞入几条相似度很低但却是“最相关”的旧记忆，结果AI的回复变得莫名其妙，总是试图把话题扯回过去。加上阈值过滤后，在新话题下，如果旧记忆都不相关，系统就提供一个“干净”的上下文，让AI正常开启新对话，体验流畅了很多。

3.3 短期记忆与长期记忆的协同

Samantha的记忆系统是分层的：

• 短期记忆：保存在运行内存中的最近若干轮对话（例如最近10轮）。这保证了对话最基本的连贯性，避免出现“你上一句说了什么？”的失忆。通常以列表或队列形式存储在应用内存中。
• 长期记忆：存储在向量数据库中的经过提炼的结构化记忆片段。

它们的协同方式是：短期记忆作为对话的“工作台”，长期记忆作为“资料库”。每次生成回复时，上下文由“系统指令 + 检索到的长期记忆 + 短期记忆 + 用户当前输入”构成。当对话轮数超过短期记忆容量时，最旧的对话会被移出短期记忆区，但在此之前，系统可能会触发一个“记忆沉淀”过程，尝试将那些有价值的短期对话提炼成长期记忆片段。

注意事项：短期记忆的轮数需要谨慎设置。轮数太少，对话显得跳跃；轮数太多，会挤占宝贵的上下文窗口（Context Window）令牌数，留给长期记忆和生成回复的空间就少了。对于拥有128K上下文窗口的模型，可以设置较长的短期记忆（如30轮）；对于4K或8K的模型，可能只能保留5-10轮。

4. 实操部署与核心环节实现

下面，我将以一个基于OpenAI API + ChromaDB + FastAPI的简化技术栈为例，拆解Samantha核心功能的实现步骤。假设你已经具备基本的Python和命令行操作知识。

4.1 环境准备与依赖安装

首先，创建一个新的项目目录并初始化虚拟环境，这是保持环境干净的好习惯。

mkdir samantha-project && cd samantha-project python -m venv venv # Windows: venv\Scripts\activate # Linux/Mac: source venv/bin/activate

安装核心依赖。我们将使用openai库调用GPT，chromadb作为向量数据库，langchain库虽然庞大，但其提供的LLM和向量库接口能极大简化代码（这里我们主要用其概念，代码会保持清晰）。

pip install openai chromadb langchain langchain-openai tiktoken fastapi uvicorn

tiktoken用于计算Token，管理上下文长度；fastapi和uvicorn用于构建一个简单的Web API服务。

4.2 构建记忆存储与检索引擎

这是最核心的模块。我们创建一个memory_manager.py文件。

import chromadb from chromadb.config import Settings from openai import OpenAI import json from datetime import datetime import uuid # 初始化OpenAI客户端和嵌入模型 client = OpenAI(api_key="你的OpenAI API密钥") EMBEDDING_MODEL = "text-embedding-3-small" class MemoryManager: def __init__(self, persist_directory="./chroma_db"): # 初始化Chroma客户端，设置持久化路径 self.chroma_client = chromadb.PersistentClient(path=persist_directory) # 获取或创建一个名为“samantha_memories”的集合（Collection） self.collection = self.chroma_client.get_or_create_collection(name="samantha_memories") def _get_embedding(self, text): """调用OpenAI API获取文本的嵌入向量""" response = client.embeddings.create(model=EMBEDDING_MODEL, input=text) return response.data[0].embedding def add_memory(self, memory_text, metadata=None): """添加一条记忆到向量数据库""" if metadata is None: metadata = {} # 生成唯一ID和时间戳 memory_id = str(uuid.uuid4()) metadata["timestamp"] = datetime.now().isoformat() # 获取文本向量 embedding = self._get_embedding(memory_text) # 存入ChromaDB self.collection.add( embeddings=[embedding], documents=[memory_text], # 存储原始文本 metadatas=[metadata], # 存储元数据 ids=[memory_id] # 存储唯一ID ) print(f"记忆已添加: {memory_text[:50]}...") return memory_id def retrieve_relevant_memories(self, query_text, top_k=5, threshold=0.7): """根据查询文本检索最相关的记忆""" # 获取查询文本的向量 query_embedding = self._get_embedding(query_text) # 从ChromaDB中查询 results = self.collection.query( query_embeddings=[query_embedding], n_results=top_k ) relevant_memories = [] # results['distances'] 是余弦距离，需要转换为相似度 (1 - distance) if results['distances']: for doc, dist, meta in zip(results['documents'][0], results['distances'][0], results['metadatas'][0]): similarity = 1 - dist if similarity >= threshold: relevant_memories.append({ "content": doc, "similarity": similarity, "metadata": meta }) # 按相似度从高到低排序 relevant_memories.sort(key=lambda x: x['similarity'], reverse=True) return relevant_memories def list_all_memories(self): """列出所有记忆（仅用于调试）""" return self.collection.get()

代码解析：

• MemoryManager类封装了所有记忆相关的操作。
• _get_embedding方法调用OpenAI的嵌入模型API，将文本转换为向量。这是产生费用的地方，但嵌入模型比GPT模型便宜得多。
• add_memory方法将一段记忆文本、其向量以及元数据（如时间戳、类别）存储到ChromaDB中。
• retrieve_relevant_memories是核心检索功能。它计算查询向量与库中所有记忆向量的相似度，返回超过阈值的最相似的top_k条记忆。这里使用余弦距离，相似度 = 1 - 距离。
• ChromaDB会自动持久化数据到指定目录，重启服务后记忆不会丢失。

4.3 实现对话生成与记忆整合逻辑

接下来，我们创建samantha_core.py来整合LLM对话和记忆管理。

from memory_manager import MemoryManager from openai import OpenAI import tiktoken class SamanthaCore: def __init__(self, memory_manager): self.memory_manager = memory_manager self.llm_client = OpenAI(api_key="你的OpenAI API密钥") self.llm_model = "gpt-3.5-turbo" # 可升级为 gpt-4 self.short_term_memory = [] # 短期记忆，存储最近的对话轮次 self.max_short_term_turns = 10 # 短期记忆最大轮数 self.encoding = tiktoken.encoding_for_model(self.llm_model) # 定义Samantha的系统角色提示词 self.system_prompt = """你是一个名叫Samantha的AI伴侣，友好、善解人意且富有好奇心。你拥有与用户互动的长期记忆。 以下是关于用户的已知信息（相关记忆）： {relevant_memories} 以下是最近的对话历史（短期记忆）： {conversation_history} 请基于以上背景信息，自然、共情地回应用户的最新消息。你的回复应该连贯、个性化，并体现出你对用户的了解。如果记忆中的信息与当前对话高度相关，可以自然地引用。""" def _count_tokens(self, text): """粗略计算文本的token数""" return len(self.encoding.encode(text)) def _format_context(self, user_input): """组装完整的对话上下文""" # 1. 检索相关长期记忆 relevant_mems = self.memory_manager.retrieve_relevant_memories(user_input, top_k=5, threshold=0.65) memories_text = "\n".join([f"- {mem['content']}" for mem in relevant_mems]) if relevant_mems else "（暂无特别相关的长期记忆）" # 2. 格式化短期记忆 history_text = "" for turn in self.short_term_memory[-self.max_short_term_turns:]: # 只取最近N轮 history_text += f"用户: {turn['user']}\nSamantha: {turn['assistant']}\n" # 3. 填充系统提示词模板 full_system_prompt = self.system_prompt.format( relevant_memories=memories_text, conversation_history=history_text ) # 构建OpenAI API所需的messages列表 messages = [ {"role": "system", "content": full_system_prompt}, ] # 添加用户最新输入 messages.append({"role": "user", "content": user_input}) # 简单检查token数（生产环境需更精细管理） total_tokens = sum(self._count_tokens(msg["content"]) for msg in messages) if total_tokens > 3500: # 为gpt-3.5-turbo的4K上下文留有余地 print(f"警告：上下文Token数({total_tokens})较高，可能影响效果。") return messages def chat(self, user_input): """处理一轮用户输入，生成回复并更新短期记忆""" # 获取上下文 messages = self._format_context(user_input) # 调用LLM生成回复 response = self.llm_client.chat.completions.create( model=self.llm_model, messages=messages, temperature=0.8, # 控制创造性，0.8使得回复更自然多变 max_tokens=500 ) assistant_reply = response.choices[0].message.content # 更新短期记忆 self.short_term_memory.append({ "user": user_input, "assistant": assistant_reply }) # 保持短期记忆不超过最大轮数 if len(self.short_term_memory) > self.max_short_term_turns: self.short_term_memory.pop(0) # （可选）在此处或定期触发“记忆沉淀”逻辑，将重要的短期对话转为长期记忆 # self._condense_memory_if_needed() return assistant_reply def _condense_memory_if_needed(self): """一个简单的记忆沉淀示例：当短期记忆满时，尝试总结并添加一条长期记忆""" # 这是一个简化示例。更复杂的实现可以让LLM判断是否需要总结以及总结什么。 if len(self.short_term_memory) >= self.max_short_term_turns: # 取出最早的几轮对话进行总结 old_conversation = "\n".join([f"用户：{t['user']}\nSamantha：{t['assistant']}" for t in self.short_term_memory[:3]]) summary_prompt = f"""请将以下对话片段中，关于用户的**重要、持久的事实性信息**（如喜好、习惯、身份、经历等）提炼总结成一条简洁的陈述句。只输出总结后的句子。 对话片段： {old_conversation} 总结：""" try: summary_response = self.llm_client.chat.completions.create( model=self.llm_model, messages=[{"role": "user", "content": summary_prompt}], temperature=0.2, # 低温度，确保总结客观 max_tokens=100 ) summary = summary_response.choices[0].message.content.strip() if summary and len(summary) > 10: # 简单过滤无效总结 self.memory_manager.add_memory(summary, metadata={"type": "auto_summary"}) print(f"已自动沉淀记忆：{summary}") except Exception as e: print(f"记忆沉淀失败：{e}")

代码解析与实操要点：

• SamanthaCore类是大脑，协调记忆检索、上下文组装和LLM调用。
• _format_context方法是核心：它检索长期记忆、格式化短期记忆，并将它们与系统提示词模板结合，构造出LLM能理解的完整上下文。提示词工程（Prompt Engineering）在这里至关重要，好的提示词能引导LLM更好地利用提供的记忆。
• chat方法是主入口，处理一轮对话。它生成回复后，会立即将本轮对话存入短期记忆列表。
• _condense_memory_if_needed展示了一个简单的自动记忆沉淀思路。在实际应用中，这个逻辑可以更复杂，例如在对话自然停顿处触发，或者让用户手动确认是否添加记忆。
• Token管理：我们使用tiktoken进行粗略的token计数。对于生产环境，必须严格管理上下文长度，避免超过模型限制导致API调用失败。常见的策略包括：优先裁剪最早的短期记忆、对过长的记忆进行摘要等。

4.4 构建简易Web API服务

最后，我们创建一个main.py来启动一个FastAPI服务，提供HTTP接口。

from fastapi import FastAPI, HTTPException from pydantic import BaseModel from samantha_core import SamanthaCore, MemoryManager import uvicorn app = FastAPI(title="Samantha AI Companion API") # 全局初始化核心组件 memory_manager = MemoryManager(persist_directory="./chroma_db") samantha = SamanthaCore(memory_manager) class ChatRequest(BaseModel): message: str user_id: str = "default_user" # 可用于支持多用户，区分记忆空间 class MemoryAddRequest(BaseModel): memory_text: str @app.post("/chat") async def chat_endpoint(request: ChatRequest): """主要的聊天端点""" try: reply = samantha.chat(request.message) return {"reply": reply, "status": "success"} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.post("/memory/add") async def add_memory_endpoint(request: MemoryAddRequest): """手动添加一条记忆（供调试或用户主动使用）""" try: mem_id = memory_manager.add_memory(request.memory_text) return {"memory_id": mem_id, "status": "success"} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.get("/memory/retrieve") async def retrieve_memories(query: str = "", top_k: int = 5): """检索记忆（供调试查看）""" try: memories = memory_manager.retrieve_relevant_memories(query, top_k=top_k) return {"memories": memories, "status": "success"} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) if __name__ == "__main__": uvicorn.run(app, host="0.0.0.0", port=8000)

现在，在终端运行python main.py，你的Samantha服务就在本地的8000端口启动了。你可以使用curl、Postman或写一个简单的前端页面与之交互。

# 示例：发送聊天请求 curl -X POST "http://localhost:8000/chat" \ -H "Content-Type: application/json" \ -d '{"message": "你好，Samantha！我今天心情不太好。"}' # 示例：手动添加一条记忆 curl -X POST "http://localhost:8000/memory/add" \ -H "Content-Type: application/json" \ -d '{"memory_text": "用户今天因为工作项目延期而感到心情低落。"}'

至此，一个具备基础长期记忆功能的AI伴侣核心后端就搭建完成了。前端可以是一个简单的聊天界面，通过调用/chat接口与Samantha对话。

5. 常见问题、优化方向与排查技巧

在实际部署和运行中，你肯定会遇到各种问题。下面是我在实验过程中总结的一些常见坑点和优化思路。

5.1 常见问题速查表

5.2 高级优化方向

当你解决了基础问题后，可以考虑以下方向让Samantha更强大、更智能：

1. 记忆的动态权重与衰减：不是所有记忆都同等重要。可以为记忆引入“权重”或“新鲜度”概念。新添加的记忆权重高，随着时间推移，权重缓慢衰减。检索时，将相似度与权重结合进行排序。这样，用户最近提到的爱好会比十年前的爱好拥有更高的优先级。

2. 记忆的主动查询与推理：除了基于当前对话的被动检索，Samantha可以主动“思考”。例如，定期（或在新对话开始时）让LLM根据近期对话，生成几个可能相关的“潜在查询问题”，然后用这些问题去检索记忆，提前将更广泛的背景信息加载到上下文中。

3. 情感状态建模：在记忆元数据中记录对话的情感倾向（积极、消极、中性）。检索时，不仅可以做语义匹配，还可以做情感匹配。当用户表达悲伤时，Samantha可以优先检索那些用户曾经如何走出低谷的记忆，或者调整自己的语气以更共情。

4. 本地模型替代：为了完全的数据隐私和零成本运行，可以将OpenAI API替换为本地部署的LLM和嵌入模型。例如：

   • LLM：使用Ollama运行llama3:8b或mistral:7b。
   • 嵌入模型：使用sentence-transformers库运行all-MiniLM-L6-v2模型。 这需要修改SamanthaCore和MemoryManager中的模型调用部分，代码逻辑完全一致，只是换成本地调用。

5. 前端界面与语音交互：为你的Samantha构建一个漂亮的Web或移动端聊天界面。更进一步，集成语音识别（如Vosk、Whisper）和语音合成（如Edge-TTS、Coqui TTS）服务，打造一个真正的语音伴侣。

5.3 我的实操心得与避坑指南

• 起步宜简不宜繁：不要一开始就追求全自动的记忆沉淀、情感分析等复杂功能。先用固定的系统提示词和手动添加记忆的方式，把“检索-回复”的核心链路跑通，确保AI能正确利用你给它的记忆。这能帮你快速验证想法的可行性。

• 嵌入模型的质量至关重要：如果检索总是找不到相关记忆，首先怀疑嵌入模型。OpenAI的text-embedding-3-small效果很好但需付费。开源的BGE或all-MiniLM-L6-v2是不错的免费替代品，但在某些专业领域或中文场景下可能需要微调。选择与你的主要对话语言和领域匹配的嵌入模型。

• 提示词需要反复“调参”：系统提示词是AI行为的“宪法”。你需要像调试程序一样调试它。如果AI太啰嗦，就在提示词里加“回复请简洁”；如果AI总是忘记引用记忆，就强调“请务必结合已知信息回答”。把你的需求用清晰、无歧义的语言写进提示词。

• 成本监控必不可少：如果使用OpenAI API，务必在后台设置用量告警。嵌入和对话都会产生费用，尤其是长对话消耗的Token数是指数级增长的。在代码中加入Token计数和日志，清楚知道每一分钱花在哪里。

• 记忆的“污染”与“清洗”：AI可能会生成错误信息，如果你不小心把这些错误信息也当成“用户事实”存入记忆库，就会污染记忆池。考虑为自动沉淀的记忆设置一个“待审核”状态，或者只存储用户明确陈述的事实。定期提供一个界面，让用户查看、编辑或删除自己的记忆。

构建Samantha的过程，本质上是在探索如何让机器更好地理解并延续一段关系。它目前仍然是一个玩具，存在诸多局限，但每一次对话的连贯，每一次它“记得”你曾经说过的小事，都会带来惊喜。这个项目最大的价值不在于做出了一个多完美的产品，而在于亲手搭建并思考了“记忆”、“个性”、“连续性”这些人机交互中最迷人也是最困难的问题。你可以从这个小系统出发，不断添加新的模块，比如知识库检索、日程管理、情绪安抚技巧等等，让它真正成为一个对你有所帮助的数字伙伴。