// 第 1 天对话
User: "我是素食主义者，对乳制品过敏"
Agent: "好的，我记住了您的饮食偏好"

// 第 30 天对话（新会话）
User: "推荐晚餐食谱"
Agent: ❌ "试试这道奶油意大利面..." // 忘记了用户偏好！

优点：准确率最高 (72.9%)
缺点：
  • 延迟极高 (17.12s P95)
  • Token 消耗巨大 (26,031)
  • 成本不可持续
  • 超出上下文窗口限制

优点：结构化存储
缺点：
  • 准确率中等 (60.5%)
  • 延迟较高 (9.94s)
  • 无法处理信息冲突
  • 缺乏时间推理

优点：延迟低 (0.89s)
缺点：
  • 准确率最低 (52.9%)
  • 记忆质量差
  • 无法定制

Preparing diagram...

// Mem0 的核心 API 极其简洁
import { MemoryClient } from 'mem0ai';

const client = new MemoryClient(\{ apiKey: 'your-api-key' \});

// 添加记忆 - 自动提取关键信息
await client.add(
    '我是素食主义者，住在上海，喜欢跑步',
    \{ user_id: 'user_123' \}
);

// 搜索记忆 - 跨数据存储智能检索
const memories = await client.search(
    '推荐餐厅',
    \{ user_id: 'user_123' \}
);
// 返回: 用户是素食主义者、住在上海等相关记忆

🚀 响应速度: 91% 提升 (17s → 1.4s)
💰 Token 消耗: 9 倍降低 (26K → 3K tokens)
🎯 准确率: 比 OpenAI Memory 高 26%+

Preparing diagram...

Preparing diagram...

┌─────────────────────┬──────────┬──────────┬──────────┐
│      方法           │ 准确率   │ 延迟(P95)│  Token   │
├─────────────────────┼──────────┼──────────┼──────────┤
│ Mem0 (推荐)         │  66.88%  │  1.44s   │  1,764   │
│ 全上下文            │  72.90%  │ 17.12s   │ 26,031   │
│ OpenAI Memory       │  52.90%  │  0.89s   │  4,437   │
│ Zep                 │  65.99%  │  2.93s   │  3,911   │
│ RAG (最佳)          │  60.53%  │  9.94s   │ 16,384   │
└─────────────────────┴──────────┴──────────┴──────────┘

🏆 Mem0 关键优势:
• 相比 OpenAI: 准确率 +26%
• 相比全上下文: 延迟 -91%, Token -93%
• 相比 RAG: 准确率 +10%, Token -89%

Preparing diagram...

interface MemoryManager {
  // 处理新消息
  processMessage(userId: string, conversationId: string, message: string): Promise<void>;

  // 检索相关记忆
  retrieveMemories(userId: string, query: string, k: number): Promise<Memory[]>;

  // 获取对话摘要
  getSummary(conversationId: string): Promise<string>;
}

Preparing diagram...

const EXTRACTION_PROMPT = `
# 任务：从对话中提取关键记忆

## 对话上下文
{{conversation_summary}}

## 最近消息
{{recent_messages}}

## 新消息
{{new_message}}

## 提取规则
1. 识别显著的事实、偏好、事件、关系
2. 每个记忆必须：
   - 具体且可验证
   - 对未来对话有价值
   - 不包含冗余信息
3. 输出格式：JSON 数组

## 输出示例
[
  {
    "content": "用户是素食主义者",
    "category": "preference",
    "confidence": 0.95,
    "temporal": false
  },
  {
    "content": "用户于2023年访问日本",
    "category": "event",
    "confidence": 0.90,
    "temporal": true,
    "timestamp": "2023-06-15"
  }
]
`;

Preparing diagram...

interface ConflictResolution {
  // 时间优先：新信息覆盖旧信息
  temporal: (oldMemory: Memory, newMemory: Memory) => UpdateAction;

  // 置信度优先：高置信度记忆保留
  confidence: (oldMemory: Memory, newMemory: Memory) => UpdateAction;

  // LLM 判断：复杂冲突交给 LLM
  llmJudge: (oldMemory: Memory, newMemory: Memory, context: string) => Promise<UpdateAction>;
}

Preparing diagram...

interface SummaryStrategy {
  // 触发条件
  shouldUpdate: (messageCount: number, timeSinceLastUpdate: number) => boolean;

  // 摘要生成
  generate: (messages: Message[], oldSummary?: string) => Promise<string>;

  // 摘要压缩（超过长度限制时）
  compress: (summary: string, maxLength: number) => Promise<string>;
}

新消息 → [提取阶段] → 候选事实 → [更新阶段] → 记忆库
         ↓                        ↓
    LLM 提取显著信息         智能决策 (ADD/UPDATE/DELETE/NOOP)
    • 事实                   基于:
    • 偏好                   • 语义相似度
    • 事件                   • 时间相关性
    • 关系                   • 置信度对比

Preparing diagram...

function extractMemories(
  message: string,
  conversationId: string,
  extractionK: number
): Promise<CandidateMemory[]> {
  // 1. 获取上下文
  const summary = await getSummary(conversationId);
  const recentMessages = await getRecentMessages(conversationId, extractionK);

  // 2. 构建提取提示
  const prompt = buildExtractionPrompt({
    summary,
    recentMessages,
    newMessage: message
  });

  // 3. LLM 提取
  const candidates = await llm.extract(prompt);

  // 4. 为每个候选记忆查找相似记忆
  const enrichedCandidates = await Promise.all(
    candidates.map(async (candidate) => {
      const embedding = await generateEmbedding(candidate.content);
      const similar = await vectorStore.search(embedding, extractionK);

      return {
        ...candidate,
        embedding,
        similarMemories: similar
      };
    })
  );

  return enrichedCandidates;
}

async function decideMemoryAction(
  candidate: CandidateMemory,
  similarMemories: Memory[]
): Promise<UpdateAction> {
  // 情况 1: 无相似记忆 -> 直接添加
  if (similarMemories.length === 0) {
    return { action: 'ADD', memory: candidate };
  }

  // 情况 2: 存在高度相似记忆
  const mostSimilar = similarMemories[0];
  const similarity = cosineSimilarity(candidate.embedding, mostSimilar.embedding);

  if (similarity < 0.80) {
    // 相似度低 -> 新记忆
    return { action: 'ADD', memory: candidate };
  }

  // 情况 3: 高相似度 -> 需要进一步判断
  if (similarity > 0.95) {
    // 几乎完全相同
    if (candidate.content === mostSimilar.content) {
      return { action: 'NOOP' }; // 完全重复
    }
  }

  // 情况 4: 时间相关性判断
  if (candidate.temporal && mostSimilar.temporal) {
    const isNewer = candidate.timestamp > mostSimilar.timestamp;
    if (isNewer && candidate.confidence > 0.7) {
      return {
        action: 'UPDATE',
        oldMemoryId: mostSimilar.id,
        newMemory: candidate
      };
    }
  }

  // 情况 5: 置信度对比
  if (candidate.confidence > mostSimilar.confidence + 0.1) {
    return {
      action: 'UPDATE',
      oldMemoryId: mostSimilar.id,
      newMemory: candidate
    };
  }

  if (candidate.confidence < mostSimilar.confidence - 0.1) {
    return { action: 'NOOP' }; // 保留高置信度记忆
  }

  // 情况 6: 置信度接近但内容不同 -> LLM 判断
  if (Math.abs(candidate.confidence - mostSimilar.confidence) < 0.1) {
    const llmDecision = await llmJudgeConflict(candidate, mostSimilar);
    return llmDecision;
  }

  // 默认: 保守策略
  return { action: 'NOOP' };
}

const CONFLICT_RESOLUTION_PROMPT = `
# 任务：解决记忆冲突

## 现有记忆
内容: {{old_memory.content}}
置信度: {{old_memory.confidence}}
时间: {{old_memory.timestamp}}

## 新记忆
内容: {{new_memory.content}}
置信度: {{new_memory.confidence}}
时间: {{new_memory.timestamp}}

## 决策选项
1. KEEP_OLD - 保留现有记忆，丢弃新记忆
2. REPLACE - 用新记忆替换现有记忆
3. MERGE - 合并两个记忆为更准确的表述
4. BOTH - 两者都保留（如果不冲突）

## 输出格式
{
  "action": "REPLACE",
  "reason": "新记忆更具体且时间更新",
  "mergedContent": null  // 仅当 action=MERGE 时填写
}
`;

Preparing diagram...

function reciprocalRankFusion(
  vectorResults: Memory[],
  graphResults: Memory[],
  k: number = 60
): Memory[] {
  const scores = new Map<string, number>();

  // 计算向量检索得分
  vectorResults.forEach((memory, rank) => {
    const score = 1 / (k + rank + 1);
    scores.set(memory.id, (scores.get(memory.id) || 0) + score);
  });

  // 计算图检索得分
  graphResults.forEach((memory, rank) => {
    const score = 1 / (k + rank + 1);
    scores.set(memory.id, (scores.get(memory.id) || 0) + score);
  });

  // 排序并返回 Top-K
  return Array.from(scores.entries())
    .sort((a, b) => b[1] - a[1])
    .map(([id]) => findMemoryById(id))
    .slice(0, k);
}

// 示例：查找朋友的访问记录
MATCH (user:User {id: $userId})-[:FRIEND_OF]->(friend:User)-[:VISITED]->(place:Place)
WHERE friend.name = $friendName
RETURN friend.name, place.name, visited.date
ORDER BY visited.date DESC
LIMIT 10

// src/types/memory.ts

/**
 * 记忆实体
 */
export interface Memory {
  id: string;
  userId: string;
  content: string;
  category: MemoryCategory;
  confidence: number;
  embedding: number[];
  temporal: boolean;
  timestamp?: string;
  metadata?: Record<string, any>;
  createdAt: Date;
  updatedAt: Date;
}

/**
 * 记忆类型
 */
export type MemoryCategory = 'fact' | 'preference' | 'event' | 'relation';

/**
 * 候选记忆（提取阶段输出）
 */
export interface CandidateMemory {
  content: string;
  category: MemoryCategory;
  confidence: number;
  temporal: boolean;
  timestamp?: string;
  embedding?: number[];
  similarMemories?: Memory[];
}

/**
 * 更新操作
 */
export type UpdateActionType = 'ADD' | 'UPDATE' | 'DELETE' | 'NOOP' | 'MERGE';

export interface UpdateAction {
  action: UpdateActionType;
  memory?: CandidateMemory;
  oldMemoryId?: string;
  newMemory?: CandidateMemory;
  mergedContent?: string;
  reason?: string;
}

/**
 * 配置选项
 */
export interface Mem0Config {
  // LLM 配置
  openaiApiKey: string;
  model: string;
  embeddingModel: string;

  // 向量数据库
  pineconeApiKey: string;
  pineconeIndex: string;
  pineconeNamespace?: string;

  // 图数据库（可选）
  neo4jUri?: string;
  neo4jUser?: string;
  neo4jPassword?: string;

  // 缓存（可选）
  redisUrl?: string;

  // 算法参数
  extractionK: number;          // 提取时检索的记忆数
  retrievalK: number;           // 检索时返回的记忆数
  similarityThreshold: number;  // 相似度阈值
  confidenceThreshold: number;  // 置信度阈值

  // 性能优化
  cacheEnabled: boolean;
  cacheTTL: number;             // 缓存时间（秒）
  batchSize: number;            // 批处理大小
}

// src/mem0/MemoryManager.ts

import OpenAI from 'openai';
import { Pinecone } from '@pinecone-database/pinecone';
import { Redis } from 'ioredis';
import { ExtractionEngine } from './ExtractionEngine';
import { UpdateEngine } from './UpdateEngine';
import { RetrievalEngine } from './RetrievalEngine';
import { SummaryGenerator } from './SummaryGenerator';
import type { Mem0Config, Memory } from '../types/memory';

export class MemoryManager {
  private openai: OpenAI;
  private pinecone: Pinecone;
  private redis?: Redis;
  private config: Mem0Config;

  private extractionEngine: ExtractionEngine;
  private updateEngine: UpdateEngine;
  private retrievalEngine: RetrievalEngine;
  private summaryGenerator: SummaryGenerator;

  constructor(config: Mem0Config) {
    this.config = config;

    // 初始化外部服务
    this.openai = new OpenAI({ apiKey: config.openaiApiKey });
    this.pinecone = new Pinecone({ apiKey: config.pineconeApiKey });

    if (config.redisUrl) {
      this.redis = new Redis(config.redisUrl);
    }

    // 初始化核心引擎
    this.extractionEngine = new ExtractionEngine(this.openai, this.pinecone, config);
    this.updateEngine = new UpdateEngine(this.openai, this.pinecone, config);
    this.retrievalEngine = new RetrievalEngine(this.pinecone, this.redis, config);
    this.summaryGenerator = new SummaryGenerator(this.openai, this.redis, config);
  }

  /**
   * 处理新消息
   */
  async processMessage(
    userId: string,
    conversationId: string,
    message: string
  ): Promise<void> {
    // 1. 提取候选记忆
    const candidates = await this.extractionEngine.extract(
      userId,
      conversationId,
      message
    );

    // 2. 决策并更新记忆
    const actions = await Promise.all(
      candidates.map((candidate) => this.updateEngine.decide(userId, candidate))
    );

    // 3. 执行更新操作
    await this.updateEngine.execute(userId, actions);

    // 4. 异步更新摘要（不阻塞）
    this.summaryGenerator.updateAsync(conversationId, message).catch((err) => {
      console.error('Summary update failed:', err);
    });
  }

  /**
   * 检索相关记忆
   */
  async retrieveMemories(
    userId: string,
    query: string,
    k?: number
  ): Promise<Memory[]> {
    return this.retrievalEngine.retrieve(userId, query, k || this.config.retrievalK);
  }

  /**
   * 获取对话摘要
   */
  async getSummary(conversationId: string): Promise<string> {
    return this.summaryGenerator.get(conversationId);
  }

  /**
   * 手动添加记忆
   */
  async addMemory(userId: string, memory: Omit<Memory, 'id' | 'createdAt' | 'updatedAt'>): Promise<string> {
    const embedding = await this.generateEmbedding(memory.content);

    const memoryWithId: Memory = {
      ...memory,
      id: this.generateId(),
      embedding,
      createdAt: new Date(),
      updatedAt: new Date()
    };

    const index = this.pinecone.Index(this.config.pineconeIndex);
    await index.namespace(this.config.pineconeNamespace || userId).upsert([
      {
        id: memoryWithId.id,
        values: embedding,
        metadata: {
          userId,
          content: memory.content,
          category: memory.category,
          confidence: memory.confidence,
          temporal: memory.temporal,
          timestamp: memory.timestamp,
          createdAt: memoryWithId.createdAt.toISOString(),
          updatedAt: memoryWithId.updatedAt.toISOString()
        }
      }
    ]);

    return memoryWithId.id;
  }

  /**
   * 删除记忆
   */
  async deleteMemory(userId: string, memoryId: string): Promise<void> {
    const index = this.pinecone.Index(this.config.pineconeIndex);
    await index.namespace(this.config.pineconeNamespace || userId).deleteOne(memoryId);
  }

  /**
   * 生成嵌入向量
   */
  private async generateEmbedding(text: string): Promise<number[]> {
    const response = await this.openai.embeddings.create({
      model: this.config.embeddingModel,
      input: text
    });

    return response.data[0].embedding;
  }

  /**
   * 生成唯一 ID
   */
  private generateId(): string {
    return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

// src/mem0/ExtractionEngine.ts

import OpenAI from 'openai';
import { Pinecone } from '@pinecone-database/pinecone';
import type { Mem0Config, CandidateMemory, Memory } from '../types/memory';

export class ExtractionEngine {
  constructor(
    private openai: OpenAI,
    private pinecone: Pinecone,
    private config: Mem0Config
  ) {}

  /**
   * 从消息中提取记忆
   */
  async extract(
    userId: string,
    conversationId: string,
    message: string
  ): Promise<CandidateMemory[]> {
    // 1. 获取对话上下文
    const summary = await this.getSummary(conversationId);
    const recentMessages = await this.getRecentMessages(conversationId, 10);

    // 2. 构建提取提示
    const prompt = this.buildExtractionPrompt(summary, recentMessages, message);

    // 3. 调用 LLM 提取
    const response = await this.openai.chat.completions.create({
      model: this.config.model,
      messages: [
        {
          role: 'system',
          content: 'You are a memory extraction assistant. Extract salient information from conversations.'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      response_format: { type: 'json_object' },
      temperature: 0.3
    });

    const result = JSON.parse(response.choices[0].message.content || '{}');
    const candidates: CandidateMemory[] = result.memories || [];

    // 4. 为每个候选记忆生成嵌入并查找相似记忆
    const enrichedCandidates = await Promise.all(
      candidates.map(async (candidate) => {
        const embedding = await this.generateEmbedding(candidate.content);
        const similar = await this.findSimilarMemories(userId, embedding, this.config.extractionK);

        return {
          ...candidate,
          embedding,
          similarMemories: similar
        };
      })
    );

    return enrichedCandidates;
  }

  /**
   * 构建提取提示
   */
  private buildExtractionPrompt(
    summary: string,
    recentMessages: string[],
    newMessage: string
  ): string {
    return `
# Task: Extract Key Memories from Conversation

## Conversation Summary
${summary || 'No summary available yet.'}

## Recent Messages
${recentMessages.map((msg, i) => `${i + 1}. ${msg}`).join('\n')}

## New Message
${newMessage}

## Extraction Rules
1. Identify salient facts, preferences, events, and relationships
2. Each memory must be:
   - Specific and verifiable
   - Valuable for future conversations
   - Free of redundant information
3. Categorize each memory: fact, preference, event, relation
4. Assign confidence score (0-1)
5. Mark if temporal (time-sensitive)

## Output Format (JSON)
{
  "memories": [
    {
      "content": "User is vegetarian",
      "category": "preference",
      "confidence": 0.95,
      "temporal": false
    },
    {
      "content": "User visited Japan in June 2023",
      "category": "event",
      "confidence": 0.90,
      "temporal": true,
      "timestamp": "2023-06-15"
    }
  ]
}

Extract memories now:
`;
  }

  /**
   * 生成嵌入向量
   */
  private async generateEmbedding(text: string): Promise<number[]> {
    const response = await this.openai.embeddings.create({
      model: this.config.embeddingModel,
      input: text
    });

    return response.data[0].embedding;
  }

  /**
   * 查找相似记忆
   */
  private async findSimilarMemories(
    userId: string,
    embedding: number[],
    k: number
  ): Promise<Memory[]> {
    const index = this.pinecone.Index(this.config.pineconeIndex);

    const queryResponse = await index.namespace(this.config.pineconeNamespace || userId).query({
      vector: embedding,
      topK: k,
      includeMetadata: true
    });

    return queryResponse.matches.map((match) => ({
      id: match.id,
      userId,
      content: match.metadata?.content as string,
      category: match.metadata?.category as any,
      confidence: match.metadata?.confidence as number,
      embedding: match.values || [],
      temporal: match.metadata?.temporal as boolean,
      timestamp: match.metadata?.timestamp as string | undefined,
      metadata: match.metadata,
      createdAt: new Date(match.metadata?.createdAt as string),
      updatedAt: new Date(match.metadata?.updatedAt as string)
    }));
  }

  /**
   * 获取对话摘要（简化实现）
   */
  private async getSummary(conversationId: string): Promise<string> {
    // 实际实现中应该从缓存或数据库获取
    return '';
  }

  /**
   * 获取最近消息（简化实现）
   */
  private async getRecentMessages(conversationId: string, k: number): Promise<string[]> {
    // 实际实现中应该从消息历史获取
    return [];
  }
}

// src/mem0/UpdateEngine.ts

import OpenAI from 'openai';
import { Pinecone } from '@pinecone-database/pinecone';
import type { Mem0Config, CandidateMemory, Memory, UpdateAction } from '../types/memory';

export class UpdateEngine {
  constructor(
    private openai: OpenAI,
    private pinecone: Pinecone,
    private config: Mem0Config
  ) {}

  /**
   * 决策记忆操作
   */
  async decide(userId: string, candidate: CandidateMemory): Promise<UpdateAction> {
    if (!candidate.similarMemories || candidate.similarMemories.length === 0) {
      return { action: 'ADD', memory: candidate };
    }

    const mostSimilar = candidate.similarMemories[0];
    const similarity = this.cosineSimilarity(
      candidate.embedding!,
      mostSimilar.embedding
    );

    // 低相似度 -> 新记忆
    if (similarity < this.config.similarityThreshold) {
      return { action: 'ADD', memory: candidate };
    }

    // 高相似度 -> 进一步判断
    if (similarity > 0.95 && candidate.content === mostSimilar.content) {
      return { action: 'NOOP' };
    }

    // 时间相关性判断
    if (candidate.temporal && mostSimilar.temporal) {
      if (this.isNewer(candidate, mostSimilar) && candidate.confidence > 0.7) {
        return {
          action: 'UPDATE',
          oldMemoryId: mostSimilar.id,
          newMemory: candidate
        };
      }
    }

    // 置信度对比
    const confidenceDiff = candidate.confidence - mostSimilar.confidence;

    if (confidenceDiff > 0.1) {
      return {
        action: 'UPDATE',
        oldMemoryId: mostSimilar.id,
        newMemory: candidate
      };
    }

    if (confidenceDiff < -0.1) {
      return { action: 'NOOP' };
    }

    // LLM 判断冲突
    if (Math.abs(confidenceDiff) < 0.1 && candidate.content !== mostSimilar.content) {
      return await this.llmJudgeConflict(candidate, mostSimilar);
    }

    return { action: 'NOOP' };
  }

  /**
   * 执行更新操作
   */
  async execute(userId: string, actions: UpdateAction[]): Promise<void> {
    const index = this.pinecone.Index(this.config.pineconeIndex);
    const namespace = index.namespace(this.config.pineconeNamespace || userId);

    for (const action of actions) {
      switch (action.action) {
        case 'ADD':
          if (action.memory) {
            await this.addMemory(namespace, userId, action.memory);
          }
          break;

        case 'UPDATE':
          if (action.oldMemoryId && action.newMemory) {
            await namespace.deleteOne(action.oldMemoryId);
            await this.addMemory(namespace, userId, action.newMemory);
          }
          break;

        case 'DELETE':
          if (action.oldMemoryId) {
            await namespace.deleteOne(action.oldMemoryId);
          }
          break;

        case 'MERGE':
          if (action.oldMemoryId && action.mergedContent) {
            await namespace.deleteOne(action.oldMemoryId);
            await this.addMemory(namespace, userId, {
              ...action.memory!,
              content: action.mergedContent
            });
          }
          break;

        case 'NOOP':
          // 无操作
          break;
      }
    }
  }

  /**
   * LLM 冲突判断
   */
  private async llmJudgeConflict(
    newMemory: CandidateMemory,
    oldMemory: Memory
  ): Promise<UpdateAction> {
    const prompt = `
# Task: Resolve Memory Conflict

## Existing Memory
Content: ${oldMemory.content}
Confidence: ${oldMemory.confidence}
Created: ${oldMemory.createdAt.toISOString()}

## New Memory
Content: ${newMemory.content}
Confidence: ${newMemory.confidence}
Timestamp: ${newMemory.timestamp || 'N/A'}

## Decision Options
1. KEEP_OLD - Keep existing memory, discard new
2. REPLACE - Replace with new memory
3. MERGE - Merge into more accurate statement
4. BOTH - Keep both (if not conflicting)

## Output Format (JSON)
{
  "action": "REPLACE" | "KEEP_OLD" | "MERGE" | "BOTH",
  "reason": "Brief explanation",
  "mergedContent": "Only if action=MERGE"
}

Decide now:
`;

    const response = await this.openai.chat.completions.create({
      model: this.config.model,
      messages: [
        { role: 'system', content: 'You are a memory conflict resolver.' },
        { role: 'user', content: prompt }
      ],
      response_format: { type: 'json_object' },
      temperature: 0.2
    });

    const result = JSON.parse(response.choices[0].message.content || '{}');

    switch (result.action) {
      case 'REPLACE':
        return {
          action: 'UPDATE',
          oldMemoryId: oldMemory.id,
          newMemory,
          reason: result.reason
        };

      case 'MERGE':
        return {
          action: 'MERGE',
          oldMemoryId: oldMemory.id,
          memory: newMemory,
          mergedContent: result.mergedContent,
          reason: result.reason
        };

      case 'BOTH':
        return {
          action: 'ADD',
          memory: newMemory,
          reason: result.reason
        };

      default: // KEEP_OLD
        return {
          action: 'NOOP',
          reason: result.reason
        };
    }
  }

  /**
   * 添加记忆到向量数据库
   */
  private async addMemory(
    namespace: any,
    userId: string,
    memory: CandidateMemory
  ): Promise<void> {
    const id = this.generateId();
    const now = new Date().toISOString();

    await namespace.upsert([
      {
        id,
        values: memory.embedding!,
        metadata: {
          userId,
          content: memory.content,
          category: memory.category,
          confidence: memory.confidence,
          temporal: memory.temporal,
          timestamp: memory.timestamp,
          createdAt: now,
          updatedAt: now
        }
      }
    ]);
  }

  /**
   * 余弦相似度
   */
  private cosineSimilarity(a: number[], b: number[]): number {
    const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
    const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
    const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));

    return dotProduct / (magnitudeA * magnitudeB);
  }

  /**
   * 判断新记忆是否更新
   */
  private isNewer(newMem: CandidateMemory, oldMem: Memory): boolean {
    if (!newMem.timestamp || !oldMem.timestamp) return false;
    return new Date(newMem.timestamp) > new Date(oldMem.timestamp);
  }

  /**
   * 生成唯一 ID
   */
  private generateId(): string {
    return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

// src/mem0/RetrievalEngine.ts

import { Pinecone } from '@pinecone-database/pinecone';
import { Redis } from 'ioredis';
import type { Mem0Config, Memory } from '../types/memory';

export class RetrievalEngine {
  constructor(
    private pinecone: Pinecone,
    private redis: Redis | undefined,
    private config: Mem0Config
  ) {}

  /**
   * 检索相关记忆
   */
  async retrieve(userId: string, query: string, k: number): Promise<Memory[]> {
    // 1. 检查缓存
    if (this.config.cacheEnabled && this.redis) {
      const cached = await this.getFromCache(userId, query);
      if (cached) {
        return cached;
      }
    }

    // 2. 生成查询嵌入
    const embedding = await this.generateEmbedding(query);

    // 3. 向量检索
    const memories = await this.vectorSearch(userId, embedding, k);

    // 4. 更新缓存
    if (this.config.cacheEnabled && this.redis) {
      await this.saveToCache(userId, query, memories);
    }

    return memories;
  }

  /**
   * 向量检索
   */
  private async vectorSearch(
    userId: string,
    embedding: number[],
    k: number
  ): Promise<Memory[]> {
    const index = this.pinecone.Index(this.config.pineconeIndex);

    const queryResponse = await index
      .namespace(this.config.pineconeNamespace || userId)
      .query({
        vector: embedding,
        topK: k,
        includeMetadata: true,
        includeValues: true
      });

    return queryResponse.matches.map((match) => ({
      id: match.id,
      userId,
      content: match.metadata?.content as string,
      category: match.metadata?.category as any,
      confidence: match.metadata?.confidence as number,
      embedding: match.values || [],
      temporal: match.metadata?.temporal as boolean,
      timestamp: match.metadata?.timestamp as string | undefined,
      metadata: match.metadata,
      createdAt: new Date(match.metadata?.createdAt as string),
      updatedAt: new Date(match.metadata?.updatedAt as string)
    }));
  }

  /**
   * 生成嵌入（简化实现，实际应该注入）
   */
  private async generateEmbedding(text: string): Promise<number[]> {
    // 实际实现中应该使用注入的 embedding 生成器
    // 这里返回空数组作为占位符
    return [];
  }

  /**
   * 从缓存获取
   */
  private async getFromCache(userId: string, query: string): Promise<Memory[] | null> {
    if (!this.redis) return null;

    const key = `mem0:${userId}:${this.hashQuery(query)}`;
    const cached = await this.redis.get(key);

    if (cached) {
      return JSON.parse(cached);
    }

    return null;
  }

  /**
   * 保存到缓存
   */
  private async saveToCache(
    userId: string,
    query: string,
    memories: Memory[]
  ): Promise<void> {
    if (!this.redis) return;

    const key = `mem0:${userId}:${this.hashQuery(query)}`;
    await this.redis.setex(key, this.config.cacheTTL, JSON.stringify(memories));
  }

  /**
   * 查询哈希
   */
  private hashQuery(query: string): string {
    // 简单哈希实现
    let hash = 0;
    for (let i = 0; i < query.length; i++) {
      const char = query.charCodeAt(i);
      hash = (hash << 5) - hash + char;
      hash = hash & hash;
    }
    return hash.toString(36);
  }
}

# 安装核心依赖
yarn add openai @pinecone-database/pinecone ioredis

# 类型定义
yarn add --dev @types/node

# 可选：图数据库支持
yarn add neo4j-driver

# .env
OPENAI_API_KEY=sk-...
PINECONE_API_KEY=...
PINECONE_INDEX=mem0-prod
REDIS_URL=redis://localhost:6379

# 可选：图数据库
NEO4J_URI=bolt://localhost:7687
NEO4J_USER=neo4j
NEO4J_PASSWORD=...

import { MemoryManager } from './mem0/MemoryManager';
import type { Mem0Config } from './types/memory';

// 1. 配置初始化
const config: Mem0Config = {
  // LLM 配置
  openaiApiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4o-mini',
  embeddingModel: 'text-embedding-3-small',

  // 向量数据库
  pineconeApiKey: process.env.PINECONE_API_KEY!,
  pineconeIndex: 'mem0-prod',
  pineconeNamespace: undefined, // 使用 userId 作为 namespace

  // 缓存
  redisUrl: process.env.REDIS_URL,

  // 算法参数
  extractionK: 10,
  retrievalK: 5,
  similarityThreshold: 0.80,
  confidenceThreshold: 0.7,

  // 性能优化
  cacheEnabled: true,
  cacheTTL: 3600, // 1 小时
  batchSize: 100
};

const memoryManager = new MemoryManager(config);

// 2. 处理消息并构建记忆
await memoryManager.processMessage(
  'user_alice',
  'conv_001',
  "I'm vegetarian and allergic to dairy"
);

// 3. 后续对话自动使用记忆
const memories = await memoryManager.retrieveMemories(
  'user_alice',
  "What are good dinner recipes?",
  5
);

console.log('Retrieved memories:', memories);
// 自动检索到素食和乳制品过敏信息！

// examples/chat-with-memory.ts

import { MemoryManager } from './mem0/MemoryManager';
import OpenAI from 'openai';

async function chatWithMemory() {
  // 初始化
  const memoryManager = new MemoryManager({
    openaiApiKey: process.env.OPENAI_API_KEY!,
    model: 'gpt-4o-mini',
    embeddingModel: 'text-embedding-3-small',
    pineconeApiKey: process.env.PINECONE_API_KEY!,
    pineconeIndex: 'mem0-demo',
    extractionK: 10,
    retrievalK: 5,
    similarityThreshold: 0.80,
    confidenceThreshold: 0.7,
    cacheEnabled: true,
    cacheTTL: 3600,
    batchSize: 100
  });

  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

  const userId = 'user_demo';
  const conversationId = 'conv_demo';

  // 对话循环
  const messages: Array<{ role: 'user' | 'assistant'; content: string }> = [];

  async function chat(userMessage: string): Promise<string> {
    console.log(`\n👤 User: ${userMessage}`);

    // 1. 处理消息并更新记忆
    await memoryManager.processMessage(userId, conversationId, userMessage);

    // 2. 检索相关记忆
    const relevantMemories = await memoryManager.retrieveMemories(
      userId,
      userMessage,
      5
    );

    // 3. 构建带记忆的提示
    const memoryContext = relevantMemories.length > 0
      ? `\n## User's Memory:\n${relevantMemories.map(m => `- ${m.content}`).join('\n')}\n`
      : '';

    messages.push({ role: 'user', content: userMessage });

    // 4. 调用 LLM 生成回复
    const response = await openai.chat.completions.create({
      model: 'gpt-4o-mini',
      messages: [
        {
          role: 'system',
          content: `You are a helpful assistant with access to the user's memory.${memoryContext}\n\nUse the memory to provide personalized responses.`
        },
        ...messages
      ]
    });

    const assistantMessage = response.choices[0].message.content || '';
    messages.push({ role: 'assistant', content: assistantMessage });

    console.log(`🤖 Assistant: ${assistantMessage}`);

    return assistantMessage;
  }

  // 示例对话
  await chat("Hi! I'm Alice, a software engineer from NYC.");
  await chat("I love running in Central Park on weekends.");
  await chat("My favorite cuisine is Japanese food.");
  await chat("I'm planning a trip to Japan next month.");

  // 新会话 - 测试记忆检索
  console.log('\n\n=== New Conversation ===\n');
  const newConversationId = 'conv_demo_2';

  const memories = await memoryManager.retrieveMemories(
    userId,
    "What do you know about me?",
    10
  );

  console.log('\n📚 Retrieved Memories:');
  memories.forEach((mem, i) => {
    console.log(`${i + 1}. [${mem.category}] ${mem.content} (confidence: ${mem.confidence})`);
  });
}

chatWithMemory().catch(console.error);

// examples/recommendation-system.ts

import { MemoryManager } from './mem0/MemoryManager';

class PersonalizedRecommendationSystem {
  private memoryManager: MemoryManager;

  constructor(config: Mem0Config) {
    this.memoryManager = new MemoryManager(config);
  }

  /**
   * 处理用户行为并更新记忆
   */
  async trackUserBehavior(
    userId: string,
    behavior: {
      type: 'view' | 'purchase' | 'like' | 'dislike';
      item: string;
      category: string;
      timestamp: string;
    }
  ): Promise<void> {
    const message = this.behaviorToMessage(behavior);

    await this.memoryManager.processMessage(
      userId,
      `behavior_${userId}`,
      message
    );
  }

  /**
   * 生成个性化推荐
   */
  async getRecommendations(
    userId: string,
    context: string
  ): Promise<string[]> {
    // 检索用户偏好记忆
    const memories = await this.memoryManager.retrieveMemories(
      userId,
      `preferences for ${context}`,
      10
    );

    // 基于记忆生成推荐
    const preferences = memories
      .filter(m => m.category === 'preference')
      .map(m => m.content);

    const dislikes = memories
      .filter(m => m.content.includes('dislike') || m.content.includes('allergic'))
      .map(m => m.content);

    // 这里可以接入实际的推荐引擎
    return this.generateRecommendations(preferences, dislikes, context);
  }

  private behaviorToMessage(behavior: any): string {
    const actions = {
      view: 'viewed',
      purchase: 'purchased',
      like: 'liked',
      dislike: 'disliked'
    };

    return `User ${actions[behavior.type]} ${behavior.item} in ${behavior.category} category on ${behavior.timestamp}`;
  }

  private generateRecommendations(
    preferences: string[],
    dislikes: string[],
    context: string
  ): string[] {
    // 简化实现
    return [
      `Recommendation based on: ${preferences.join(', ')}`,
      `Avoiding: ${dislikes.join(', ')}`
    ];
  }
}

// 使用示例
const recommender = new PersonalizedRecommendationSystem(config);

// 跟踪用户行为
await recommender.trackUserBehavior('user_123', {
  type: 'like',
  item: 'Vegetarian Sushi',
  category: 'Japanese Food',
  timestamp: '2025-11-17T10:00:00Z'
});

// 获取推荐
const recommendations = await recommender.getRecommendations(
  'user_123',
  'dinner options'
);