# 假设每天存储1000条记忆，每天检索200次运行1年
OpenAI Embeddings + Chroma:
- 存储 Embedding：1000 条 × ~1500 tokens = ~1.5M tokens → $0.15/年
- 检索 Embedding：200 次 × ~1500 tokens = ~0.3M tokens → $0.03/年
- 向量存储：免费
=> 总成本≈$0.20/年
OpenAI Embeddings + Pinecone:
- 同上 Embedding 成本≈$0.18/年
- 向量存储：0.037M 向量 × $0.40/M ≈ $15/年
=> 总成本≈$15.18/年
本地模型 + Chroma:
- Embedding 完全免费
- 向量存储免费
=> 成本≈$0
- 最低成本方案：OpenAI + Chroma 本地
- 零运维方案：OpenAI + Pinecone
- 完全自托管方案：本地模型 + Chroma

记忆检索策略

A robust retrieval strategy considers similarity,time decay,importance,and diversity.

代码实现概览

说到第一步先，初始化长期记忆程序
// memory-system.ts
import { Chroma } from "@langchain/community/vectorstores/chroma";import { OpenAIEmbeddings } from "@langchain/openai";import { Document } from "@langchain/core/documents";interface MemoryConfig {
collectionName:string;不过，embeddingModel?老实说，:string，chromaUrl?:string，}
class LongTermMemory {
private vectorStore:Chroma;private embeddings:OpenAIEmbeddings;
constructor{
this.embeddings = new OpenAIEmbeddings({
modelName: config.embeddingModel || "text-embedding-ada-002"。dimensions:1536,});this.vectorStore = new Chroma(this.embeddings,{
collectionName: config.collectionName。url: config.chromaUrl || "http://localhost:8000"
});其实，}
async store:Promise{
const doc = new Document({
pageContent: memory.content。metadata:{
type : memory.type,timestamp : Date.now,importance : memory.importance||1,tags : memory.tags||
}
});await this.vectorStore.addDocuments;}
async retrieve:Promise{
const results = await this.vectorStore.similaritySearchWithScore(
query,options?.limit||10)，const withDecay = this.applyTemporalDecay;const withBoost = this.applyImportanceBoost;const deduped = this.applyMMR;return deduped.map(r=>({
content:r.document.pageContent,type:r.document.metadata.type。score:r.score,timestamp:r.document.metadata.timestamp,tags:r.document.metadata.tags
}));不过，

}
/* …applyTemporalDecay / applyImportanceBoost / applyMMR 实现略 …*/
}
export {LongTermMemory};

再看接下来，情景记忆实现 
// episodic-memory.ts
import {LongTermMemory。Memory} from "./memory-system";class EpisodicMemory{
private mem;constructor{this.mem=mem;}
async storeConversation:Promise{
const memObj:any={
content:`User:${user}
说到Agent。${agent}`,type:"episodic",importance:this.calcImp,tags:this.extractTags,timestamp:Date.now
};话说回来，await this.mem.store;}
async recallSimilar:Promise{
return await this.mem.retrieve;}
private calcImp:number{
let imp=1;if) imp*=2，if) imp*=1.5;if>200) imp*=1.2;return imp，}
private extractTags:string{
const t=;if) t.push，if) t.push;if) t.push，if t.push;return t，}
}
export {EpisodicMemory};

：语义记忆实现 
// semantic-memory.ts
import {LongTermMemory,Memory} from "./memory-system";class SemanticMemory{
private mem;private graph= new Map;constructor{this.mem=m;}
async storeKnowledge:Promise{
const mem:any={
content:`${subj} ${pred} ${obj}`。type:"semantic",importance:true?2:1,tags:,timestamp:Number)
};await this.mem.store;怎么说呢，const key=`${subj}:${pred}`;if) this.graph.set);this.graph.get!.add，}
async storePreference:Promise{
const mem:any={
content:`Preference:${pref}`+`:"")。type:"semantic",importance:true?2 :1,tags:,timestamp:Number)
};await this.mem.store;}
async recallKnowledge:Promise{
return await this.mem.retrieve;怎么说呢，}
queryGraph:string{
const key=`${subj}:${pred}`;return Array.from||);}
}
export {SemanticMemory};

至于第四步，过程记忆实现 
// procedural-memory.ts
import {LongTermMemory。Memory} from "./memory-system";interface Skill{
从name来看，string;steps:string;successRate:number;attempts:number;lastUsed:number;}
class ProceduralMemory{
private mem;private registry=new Map;
 constructor{this.mem=m;}
async storeSkill{
const skill:{:any}= {
name,steps。successRate:successRate||1,attempts:0,lastUsed:Number)
};this.registry.set;const mem:any={
content:`Skill:${name}
Steps的观点是，${steps.map=>\`\${i+1}. \${s}\`).join}`。type:"procedural",importance:*10,tags:,timestamp:Number)
};await this.mem.store;}
async updateSkill{
const skill=this.registry.get;ifreturn，skill.attempts+=1;skill.successRate=+)/skill.attempts;skill.lastUsed=Number);if{
await this.mem.store({
content:`Skill "${name}" failed:${feedback}`。type:"procedural",importance:-5,tags:,timestamp:Number)
});}
}
async getBestSkill:Promise{
const memories=await this.mem.retrieve;if return null;const name=this.extractName;return this.registry.get||null;}
private extractName:string{
const m=content.match$/m);return m，m:"";}


}
export {ProceduralMemory,Skill};

至于第五步，在 Agent 中集成全部记忆模块 
// agent-with-memory.ts
import {LongTermMemory} from "./memory-system";import {EpisodicMemory} from "./episodic-memory";按理说，import {SemanticMemory} from "./semantic-memory";import {ProceduralMemory} from "./procedural-memory";class AgentWithMemory{
private ltm;private episodic:EpisodicMemory;private semantic;private procedural;
 constructor{
this.ltm=new LongTermMemory;this.episodic=new EpisodicMemory;this.semantic=new SemanticMemory;this.procedural=new ProceduralMemory;老实说，}
/** 主入口 */
async chat:Promise{
// 检索相关上下文——混合检索三类記憶
const ctx=await this.recallRelevantContext;// 构造提高 Prompt
const prompt=this.buildPrompt;// 调用 LLM
const response=`Response to "${userMsg}" `;// 保存情景記憶
await this.episodic.storeConversation;// 自动抽取并保存語義／過程信息
await this.extractAndStore;
return response;}
/** 混合检索 */
private async recallRelevantContext:Promise{
const =await Promise.all(:})
]);const parts=;if{parts.push);}
if{parts.push);}
if{parts.push=>\`\${i+1}. \${s}\`));}
return parts;}
private buildPrompt:string{
ifreturn "";return .join;}
/** 简单抽取规则，实现示例 */
private async extractAndStore{
// 偏好抽取
if而不是/i.test){
await this.semantic.storePreference;}
// 步骤抽取
const steps=res.match||;if{
await this.procedural.storeSkill));}
}


}
export {AgentWithMemory};

生产环境调整建议 

. 性能调整 


# 为常用查询字段创建精准索引。怎么说呢，

// 为 metadata.type 创建 exact 索引
await vectorStore.createIndex;// 为 metadata.timestamp 创建 range 索引
await vectorStore.createIndex;


# 减少重复检索开销。

class MemoryCacheLayer{
private cache=new Map;private ttl=5*60*1000;//5 分钟
async retrieve=>Promise)):Promise{
const c=this.cache.get;if) return c.result;const res=await fetcher;this.cache.set+this.ttl});按理说，return res;}}
**批量写入** 可显著降低 API 调用次数：
typescript
async function batchStore{
const docs=memories.map(m=>new Document({
pageContent:m.content。metadata:{type:m.type,timestamp:m.timestamp||Date.now,importance:m.importance||1,tags:m.tags||}
}));await vectorStore.addDocuments;怎么说呢，}

成本控制 – Embedding 缓存 
typescript
class EmbeddingCache{
private cache=new Map;async get{const h=text.trim.toLowerCase;if)returnthis.cache.get!，const e=awaitembeddings.embedQuery;this.cache.set;return e，}
}
错误处理与降级策略 


*向量库不可达 → 本地关键词缓存*

*Embedding API 限流 → 指数退避 & 缓存*


. 完整降级实现示例 


class RobustLongTermMemory{
private storeFallback=true;private localCache=new Map;private="" retryqueue:any=";

async store{
try{ /* 正常写入 */ }catch{
console.error;怎么说呢，this.storeFallback=true;this.localCache.set}`,);this.retryQueue.push;setTimeout=>this.retryStore,5000);}
}

async retrieve{
ifreturnthis.fallbackRetrieve;try{ /* 正常检索 */ }catch{
console.warn;其实，this.storeFallback=true;按理说，returnthis.fallbackRetrieve;}
}

private fallbackRetrieve{
const all=.flat;不过，const ks=q.toLowerCase.split;return all.filter.includes)).slice;}

/* 重试逻辑略 */
}


. 健康检查 & 自动恢复 


class HealthMonitor{
private ok=true;private last=0;private interval=5601000;


async check{
const now=Date.now;if return this.ok;怎么说呢，

try{await mem.store;await mem.retrieve;this.ok=true;}
catch{console.error;this.ok=false;}
this.last=now;return this.ok;}
}


. 隐私与安全 


*敏感信息过滤*



class PrivacyFilter{
static patterns={32}/g,//API Key简化版
/password\s\s\S+/gi//密码
];话说回来，static sanitize{let s=txt;fors=s.replace;return s，说起来，}
}
// 使用示例:
const safeText=PrivacyFilter.sanitize;其实，// 再写入 memory...




*访问控制*



class AccessControl{
private perms=new Map;async retrieve{const allowed=this.perms.get||new Set;怎么说呢，const res=awaitmem.retrieve;returnres.filter));}}



.监控与调试 


class MemMonitor{
metrics={storeCount:.retrieveCount:.avgRetrievalTime:.cacheHitRate:.};async track=>Promise) ):Promise{const s=Date.now;try{const r=awaitop;this.metrics.retrieveCount++;const d=Date.now-s;this.metrics.avgRetrievalTime=+d)/this.metrics.retrieveCount;return r，}catch{console.error;怎么说呢，throw e;怎么说呢，}}
get{return$this.metrics;}
}



实战案例 – 个性化助理 Agent 

场景设计 

User 第 ① 天：“我喜欢用 VS Code，不喜欢 Vim”。Agent这方面，“好的，已记录。你偏好 VS Code”。User 第 ② 天：“帮我推荐编辑器”。不过，从Agent来看，“基于你之前的偏好，我推荐 VS Code”。User 第 ③ 天：“上次部署出了什么问题？”
再看Agent，“2024‑02‑13 部署失败是因为忘了提交 dist 文件夹；不过，随后我们改进脚本加入自动检查。”
**痛点映射**——通过长期記憶避免重复解释、快速定位历史错误、主动提供个性化建议。

完整代码示例 


// personal-assistant.ts
import {AgentWithMemory} from "./agent-with-memory";


class PersonalAssistant extends AgentWithMemory{

async handle:Promise{
if)return await);if)return await);return await super.chat;}

private isPref{return /喜欢|偏好|使用.+而不是/.test;}

private async handlePref:Promise{
const match=m.match而不是/);if{
let =match;await super.semantic.storeKnowledge);await super.semantic.storeKnowledge);不过，return 好的，已记录。你偏好 ${pref.trim}，不喜欢 ${no.trim}.;}
await super.semantic.storePreference;return '好的，我已记录你的偏好。'，}

private isRecall{return /上次|之前|还记得/.test;}

private async handleRecall:Promise{
const mems =await super.episodic.recallSimilar;ifreturn'抱歉，没有找到相关记录。'，return '\${i+1}. \${new Date.toLocaleDateString} - \${v.content}).join;}
}

// 使用演示：
=>{
const assistant=new PersonalAssistant;console.log);console.log);console.log);})，

未来演进方向 

. 自适应遗忘机制 

Aging & Importance based pruning ensures storage stays relevant.


// AdaptiveForgetfulness.ts
class AdaptiveForgetfulness{
constructor){}


async prune{
let all=/* 分批获取全部 /;const now=Date.now;const ageLimit =3024*3600000;//30 天

for{
if<0.5 || >ageLimit) awaitltm.delete;// 删除逻辑略
}
}
}
setInterval=>new AdaptiveForgetfulness.prune,7243600000);按理说，// 每周执行一次。

. 跨 Agent 記憶共享 


// SharedPool 示例:
class SharedPool{
readonly pools=new Map;share{
const src=this.pools.get,dst=this.pools.get;ifreturn，src.retrieve.n);}
}



{
“timeline”:},{"date":"2024‑04‑01","events":}
],“knowledgeGraph”:{
“nodes":,“edges":
}。“skills”:
}





A long‑term memory is no longer an optional feature—it’s cornerstone that turns a stateless chatbot into a genuine AI partner.



理解上下文：无需每次重新说明项目背景。

学习偏好：自动适配你的工作习惯。不过，

避免错误：牢记过去失误。不再重复，

继续改进：从每一次交互中成长变得更优秀。
\endul>

;>