用户: 我喜欢吃素食，不吃奶制品
Agent: 好的，明白了
---
[下一次会话]
---
用户: 推荐一些食谱
Agent: 试试奶油意大利面怎么样？
用户: 😤 我刚告诉过你我不吃奶制品！

用户: 我喜欢吃素食，不吃奶制品
Agent: 好的，我记住了
---
[下一次会话]
---
用户: 推荐一些食谱
Agent: 基于你的素食和无奶制品偏好，试试腰果酱意大利面？

interface ShortTermMemory {
  conversationHistory: Message[];
  currentContext: {
    topic: string;
    entities: string[];
    lastUpdate: Date;
  };
}

class WorkingMemory {
  private messages: Message[] = [];
  private maxMessages: number = 10;

  addMessage(message: Message): void {
    this.messages.push(message);
    
    // 保持滚动窗口
    if (this.messages.length > this.maxMessages) {
      this.messages.shift();
    }
  }

  getContext(): Message[] {
    return this.messages;
  }

  clear(): void {
    this.messages = [];
  }
}

interface SemanticMemory {
  facts: Fact[];
  concepts: Concept[];
  rules: Rule[];
  relationships: Relationship[];
}

interface Fact {
  id: string;
  subject: string;
  predicate: string;
  object: string;
  confidence: number;
  timestamp: Date;
  source?: string;
}

// 示例：存储用户偏好
const userPreferences: Fact[] = [
  {
    id: "fact_001",
    subject: "user_alice",
    predicate: "prefers",
    object: "vegetarian_diet",
    confidence: 0.95,
    timestamp: new Date(),
    source: "conversation"
  },
  {
    id: "fact_002",
    subject: "user_alice",
    predicate: "allergic_to",
    object: "dairy",
    confidence: 1.0,
    timestamp: new Date(),
    source: "conversation"
  }
];

import { Pinecone } from '@pinecone-database/pinecone';
import { OpenAI } from 'openai';

class SemanticMemoryStore {
  private pinecone: Pinecone;
  private openai: OpenAI;
  private indexName: string;

  constructor(apiKey: string, indexName: string) {
    this.pinecone = new Pinecone({ apiKey });
    this.openai = new OpenAI();
    this.indexName = indexName;
  }

  async storeFact(fact: string, metadata: Record<string, any>): Promise<void> {
    // 生成向量嵌入
    const embedding = await this.openai.embeddings.create({
      model: "text-embedding-3-small",
      input: fact,
    });

    const index = this.pinecone.Index(this.indexName);
    
    // 存储到向量数据库
    await index.upsert([{
      id: metadata.id || `fact_${Date.now()}`,
      values: embedding.data[0].embedding,
      metadata: {
        text: fact,
        ...metadata,
        timestamp: new Date().toISOString()
      }
    }]);
  }

  async retrieveRelevantFacts(query: string, topK: number = 5): Promise<any[]> {
    // 生成查询向量
    const queryEmbedding = await this.openai.embeddings.create({
      model: "text-embedding-3-small",
      input: query,
    });

    const index = this.pinecone.Index(this.indexName);
    
    // 语义搜索
    const results = await index.query({
      vector: queryEmbedding.data[0].embedding,
      topK,
      includeMetadata: true
    });

    return results.matches || [];
  }
}

interface Episode {
  id: string;
  timestamp: Date;
  sessionId: string;
  context: {
    location?: string;
    participants: string[];
    topic: string;
  };
  events: Event[];
  outcome: {
    success: boolean;
    feedback?: string;
    metrics?: Record<string, number>;
  };
  tags: string[];
}

interface Event {
  type: 'user_message' | 'agent_action' | 'tool_call' | 'error';
  timestamp: Date;
  content: string;
  metadata?: Record<string, any>;
}

// 示例：记录支持对话
const customerSupportEpisode: Episode = {
  id: "episode_cs_001",
  timestamp: new Date("2025-01-15T10:30:00Z"),
  sessionId: "session_abc123",
  context: {
    participants: ["user_alice", "agent_support"],
    topic: "payment_issue"
  },
  events: [
    {
      type: "user_message",
      timestamp: new Date("2025-01-15T10:30:00Z"),
      content: "My payment failed but money was deducted"
    },
    {
      type: "agent_action",
      timestamp: new Date("2025-01-15T10:30:15Z"),
      content: "Checking transaction history"
    },
    {
      type: "tool_call",
      timestamp: new Date("2025-01-15T10:30:20Z"),
      content: "query_payment_database",
      metadata: { transactionId: "txn_xyz789" }
    }
  ],
  outcome: {
    success: true,
    feedback: "Issue resolved within 5 minutes",
    metrics: { resolutionTime: 300, satisfactionScore: 5 }
  },
  tags: ["payment", "refund", "resolved"]
};

import { MongoClient, Db } from 'mongodb';

class EpisodicMemoryStore {
  private db: Db;
  private collection: string = 'episodes';

  constructor(mongoUrl: string, dbName: string) {
    const client = new MongoClient(mongoUrl);
    this.db = client.db(dbName);
  }

  async storeEpisode(episode: Episode): Promise<void> {
    await this.db.collection(this.collection).insertOne({
      ...episode,
      _createdAt: new Date()
    });
  }

  async retrieveSimilarEpisodes(
    query: {
      topic?: string;
      tags?: string[];
      participantId?: string;
      timeRange?: { start: Date; end: Date };
    },
    limit: number = 10
  ): Promise<Episode[]> {
    const filter: any = {};

    if (query.topic) {
      filter['context.topic'] = query.topic;
    }

    if (query.tags && query.tags.length > 0) {
      filter.tags = { $in: query.tags };
    }

    if (query.participantId) {
      filter['context.participants'] = query.participantId;
    }

    if (query.timeRange) {
      filter.timestamp = {
        $gte: query.timeRange.start,
        $lte: query.timeRange.end
      };
    }

    const episodes = await this.db
      .collection(this.collection)
      .find(filter)
      .sort({ timestamp: -1 })
      .limit(limit)
      .toArray();

    return episodes as unknown as Episode[];
  }

  async getEpisodesByOutcome(
    successOnly: boolean = true,
    limit: number = 10
  ): Promise<Episode[]> {
    const episodes = await this.db
      .collection(this.collection)
      .find({ 'outcome.success': successOnly })
      .sort({ 'outcome.metrics.satisfactionScore': -1 })
      .limit(limit)
      .toArray();

    return episodes as unknown as Episode[];
  }
}

interface Procedure {
  id: string;
  name: string;
  description: string;
  category: string;
  steps: ProcedureStep[];
  preconditions: Condition[];
  postconditions: Condition[];
  successRate: number;
  lastUsed: Date;
  usageCount: number;
}

interface ProcedureStep {
  order: number;
  action: string;
  parameters?: Record<string, any>;
  expectedDuration?: number;
  fallbackSteps?: ProcedureStep[];
}

interface Condition {
  type: 'requirement' | 'expected_result';
  description: string;
  validator?: (context: any) => boolean;
}

// 示例：API 认证流程
const apiAuthProcedure: Procedure = {
  id: "proc_auth_001",
  name: "API Authentication Flow",
  description: "Standard OAuth 2.0 authentication procedure",
  category: "security",
  steps: [
    {
      order: 1,
      action: "redirect_to_oauth_provider",
      parameters: {
        clientId: "${CLIENT_ID}",
        redirectUri: "${REDIRECT_URI}",
        scope: "read write"
      }
    },
    {
      order: 2,
      action: "receive_authorization_code",
      expectedDuration: 30000 // 30 seconds
    },
    {
      order: 3,
      action: "exchange_code_for_token",
      parameters: {
        tokenEndpoint: "${TOKEN_ENDPOINT}"
      },
      fallbackSteps: [
        {
          order: 1,
          action: "retry_with_exponential_backoff"
        }
      ]
    }
  ],
  preconditions: [
    {
      type: 'requirement',
      description: "Valid client credentials must be configured"
    }
  ],
  postconditions: [
    {
      type: 'expected_result',
      description: "Access token and refresh token obtained"
    }
  ],
  successRate: 0.98,
  lastUsed: new Date(),
  usageCount: 1523
};

class ProceduralMemoryEngine {
  private procedures: Map<string, Procedure> = new Map();

  registerProcedure(procedure: Procedure): void {
    this.procedures.set(procedure.id, procedure);
  }

  async executeProcedure(
    procedureId: string,
    context: Record<string, any>
  ): Promise<ExecutionResult> {
    const procedure = this.procedures.get(procedureId);
    if (!procedure) {
      throw new Error(`Procedure ${procedureId} not found`);
    }

    // 验证前置条件
    const preconditionsValid = this.validateConditions(
      procedure.preconditions,
      context
    );
    
    if (!preconditionsValid) {
      return {
        success: false,
        error: "Preconditions not met"
      };
    }

    // 执行步骤
    const results: StepResult[] = [];
    for (const step of procedure.steps) {
      try {
        const stepResult = await this.executeStep(step, context);
        results.push(stepResult);
        
        if (!stepResult.success && step.fallbackSteps) {
          // 执行备用步骤
          for (const fallbackStep of step.fallbackSteps) {
            const fallbackResult = await this.executeStep(fallbackStep, context);
            if (fallbackResult.success) {
              results.push(fallbackResult);
              break;
            }
          }
        }
      } catch (error) {
        return {
          success: false,
          error: `Step ${step.order} failed: ${error}`,
          results
        };
      }
    }

    // 更新使用统计
    procedure.lastUsed = new Date();
    procedure.usageCount++;

    return {
      success: true,
      results
    };
  }

  private validateConditions(
    conditions: Condition[],
    context: Record<string, any>
  ): boolean {
    return conditions.every(condition => {
      if (condition.validator) {
        return condition.validator(context);
      }
      return true;
    });
  }

  private async executeStep(
    step: ProcedureStep,
    context: Record<string, any>
  ): Promise<StepResult> {
    // 实现具体的步骤执行逻辑
    // 这里简化为模拟执行
    console.log(`Executing: ${step.action}`);
    
    return {
      success: true,
      step: step.order,
      duration: step.expectedDuration || 0
    };
  }
}

interface ExecutionResult {
  success: boolean;
  error?: string;
  results?: StepResult[];
}

interface StepResult {
  success: boolean;
  step: number;
  duration: number;
  output?: any;
}

┌─────────────────────────────────────────────────────────────┐
│                       AI Agent Application                    │
└─────────────────────┬───────────────────────────────────────┘
                      │
                      │ LLM API Calls
                      ▼
┌─────────────────────────────────────────────────────────────┐
│                   Memory Interceptor Layer                    │
│  ┌──────────────────────────────────────────────────────┐   │
│  │  1. Pre-processing: Inject Context                   │   │
│  │  2. LLM Call: Forward to Provider                    │   │
│  │  3. Post-processing: Extract & Store                 │   │
│  └──────────────────────────────────────────────────────┘   │
└───────┬─────────────────────────────────────────┬───────────┘
        │                                         │
        ▼ Get Context                             ▼ Store Memories
┌───────────────────────────────┐   ┌─────────────────────────┐
│     Memory Retrieval System    │   │   Memory Storage Layer  │
│  ┌─────────────────────────┐  │   │  ┌──────────────────┐  │
│  │ • Semantic Search       │  │   │  │ Short-term       │  │
│  │ • Temporal Filtering    │  │   │  │ • Redis/Memory   │  │
│  │ • Relevance Ranking     │  │   │  └──────────────────┘  │
│  │ • Context Assembly      │  │   │  ┌──────────────────┐  │
│  └─────────────────────────┘  │   │  │ Semantic         │  │
└───────────────────────────────┘   │  │ • Vector DB      │  │
                                    │  └──────────────────┘  │
┌───────────────────────────────┐   │  ┌──────────────────┐  │
│  Conscious Analysis Agent      │   │  │ Episodic         │  │
│  ┌─────────────────────────┐  │   │  │ • TimeSeries DB  │  │
│  │ • Pattern Detection     │  │   │  └──────────────────┘  │
│  │ • Memory Consolidation  │  │   │  ┌──────────────────┐  │
│  │ • Promotion/Demotion    │  │   │  │ Procedural       │  │
│  │ • Conflict Resolution   │  │   │  │ • Document Store │  │
│  └─────────────────────────┘  │   │  └──────────────────┘  │
└───────────────────────────────┘   └─────────────────────────┘

/**
 * Memori 核心架构实现
 */

import { OpenAI } from 'openai';
import { EventEmitter } from 'events';

interface MemoriConfig {
  namespace: string;
  databaseUrl: string;
  openaiApiKey: string;
  autoIngest?: boolean;
  consciousIngest?: boolean;
}

class MemoriCore extends EventEmitter {
  private config: MemoriConfig;
  private openaiClient: OpenAI;
  private enabled: boolean = false;
  
  constructor(config: MemoriConfig) {
    super();
    this.config = config;
    this.openaiClient = new OpenAI({ apiKey: config.openaiApiKey });
  }

  /**
   * 启用 Memori 拦截器
   */
  enable(): void {
    if (this.enabled) return;
    
    // 拦截 OpenAI 调用
    this.interceptOpenAICalls();
    this.enabled = true;
    
    if (this.config.consciousIngest) {
      this.startConsciousAnalysis();
    }
  }

  /**
   * 拦截 LLM 调用的核心逻辑
   */
  private interceptOpenAICalls(): void {
    const originalCreate = this.openaiClient.chat.completions.create.bind(
      this.openaiClient.chat.completions
    );

    this.openaiClient.chat.completions.create = async (params: any) => {
      // Step 1: 检索相关记忆
      const relevantMemories = await this.retrieveContext(params.messages);

      // Step 2: 注入记忆到 prompt
      const enhancedMessages = this.injectMemories(
        params.messages,
        relevantMemories
      );

      // Step 3: 调用 LLM
      const response = await originalCreate({
        ...params,
        messages: enhancedMessages
      });

      // Step 4: 提取并存储新记忆
      if (this.config.autoIngest) {
        await this.extractAndStore(params.messages, response);
      }

      return response;
    };
  }

  /**
   * 检索相关上下文
   */
  private async retrieveContext(messages: any[]): Promise<Memory[]> {
    const lastUserMessage = messages
      .filter(m => m.role === 'user')
      .pop();

    if (!lastUserMessage) return [];

    // 从向量数据库中检索
    const query = lastUserMessage.content;
    const memories = await this.searchMemories({
      query,
      namespace: this.config.namespace,
      limit: 5
    });

    return memories;
  }

  /**
   * 注入记忆到消息
   */
  private injectMemories(messages: any[], memories: Memory[]): any[] {
    if (memories.length === 0) return messages;

    const memoryContext = this.formatMemoriesAsContext(memories);
    
    // 在系统消息之后插入记忆上下文
    const systemMessageIndex = messages.findIndex(m => m.role === 'system');
    
    if (systemMessageIndex >= 0) {
      return [
        messages[systemMessageIndex],
        {
          role: 'system',
          content: memoryContext
        },
        ...messages.slice(systemMessageIndex + 1)
      ];
    }

    return [
      {
        role: 'system',
        content: memoryContext
      },
      ...messages
    ];
  }

  /**
   * 格式化记忆为上下文
   */
  private formatMemoriesAsContext(memories: Memory[]): string {
    const context = memories.map(m => {
      return `[Memory from ${m.timestamp.toISOString()}]
Category: ${m.category}
Content: ${m.content}
Relevance: ${m.relevanceScore.toFixed(2)}
---`;
    }).join('\n');

    return `Relevant memories from past interactions:

${context}

Use these memories to provide personalized and contextually relevant responses.`;
  }

  /**
   * 提取并存储记忆
   */
  private async extractAndStore(messages: any[], response: any): Promise<void> {
    const conversation = {
      messages,
      response: response.choices[0].message
    };

    // 使用 LLM 提取重要信息
    const extraction = await this.openaiClient.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [
        {
          role: "system",
          content: `Extract important facts, preferences, and information from this conversation.
Format your response as JSON:
{
  "facts": ["fact1", "fact2"],
  "preferences": ["pref1", "pref2"],
  "actionItems": ["action1", "action2"]
}`
        },
        {
          role: "user",
          content: JSON.stringify(conversation)
        }
      ],
      response_format: { type: "json_object" }
    });

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

    // 存储到数据库
    await this.storeMemories(extractedData);
  }

  /**
   * 意识分析：后台处理记忆
   */
  private startConsciousAnalysis(): void {
    // 每小时运行一次
    setInterval(async () => {
      await this.analyzeAndConsolidate();
    }, 3600000);
  }

  /**
   * 分析并整合记忆
   */
  private async analyzeAndConsolidate(): Promise<void> {
    // 获取最近的记忆
    const recentMemories = await this.getRecentMemories(100);

    // 检测模式
    const patterns = await this.detectPatterns(recentMemories);

    // 提升重要记忆
    for (const pattern of patterns) {
      if (pattern.importance > 0.8) {
        await this.promoteMemory(pattern);
      }
    }

    // 解决冲突
    await this.resolveConflicts(recentMemories);
  }

  // 辅助方法
  private async searchMemories(params: any): Promise<Memory[]> {
    // 实现向量搜索
    return [];
  }

  private async storeMemories(data: any): Promise<void> {
    // 实现存储逻辑
  }

  private async getRecentMemories(limit: number): Promise<Memory[]> {
    return [];
  }

  private async detectPatterns(memories: Memory[]): Promise<Pattern[]> {
    return [];
  }

  private async promoteMemory(pattern: Pattern): Promise<void> {
    // 实现记忆提升
  }

  private async resolveConflicts(memories: Memory[]): Promise<void> {
    // 实现冲突解决
  }
}

interface Memory {
  id: string;
  content: string;
  category: 'fact' | 'preference' | 'rule' | 'summary';
  timestamp: Date;
  relevanceScore: number;
  namespace: string;
}

interface Pattern {
  type: string;
  memories: string[];
  importance: number;
}

// 使用示例
const memori = new MemoriCore({
  namespace: 'user_alice',
  databaseUrl: 'postgresql://localhost/memori',
  openaiApiKey: process.env.OPENAI_API_KEY!,
  autoIngest: true,
  consciousIngest: true
});

memori.enable();

// 之后的所有 OpenAI 调用都会自动带上记忆
const openai = new OpenAI();
const response = await openai.chat.completions.create({
  model: "gpt-4",
  messages: [
    { role: "user", content: "What's my favorite food?" }
  ]
});

/**
 * Mem0 风格的记忆系统实现
 */

interface Mem0Config {
  llmProvider: 'openai' | 'anthropic';
  apiKey: string;
  vectorDb: {
    type: 'pinecone' | 'qdrant' | 'weaviate';
    url: string;
    apiKey: string;
  };
  graphDb?: {
    type: 'neo4j';
    url: string;
    username: string;
    password: string;
  };
}

class Mem0Memory {
  private config: Mem0Config;
  private vectorStore: VectorStore;
  private graphStore?: GraphStore;

  constructor(config: Mem0Config) {
    this.config = config;
    this.vectorStore = new VectorStore(config.vectorDb);
    
    if (config.graphDb) {
      this.graphStore = new GraphStore(config.graphDb);
    }
  }

  /**
   * 添加记忆
   */
  async add(
    message: string,
    userId: string,
    metadata?: Record<string, any>
  ): Promise<MemoryAddResult> {
    // Phase 1: Extraction - 从消息中提取记忆
    const extractedMemories = await this.extractMemories(message);

    // Phase 2: Deduplication - 去重
    const newMemories = await this.deduplicateMemories(
      extractedMemories,
      userId
    );

    // Phase 3: Update - 更新现有记忆或创建新记忆
    const results: StoredMemory[] = [];
    for (const memory of newMemories) {
      const stored = await this.storeMemory(memory, userId, metadata);
      results.push(stored);
    }

    // Phase 4: Graph Relationships (如果启用)
    if (this.graphStore) {
      await this.updateGraphRelationships(results, userId);
    }

    return {
      memoriesAdded: results.length,
      memories: results
    };
  }

  /**
   * 搜索记忆
   */
  async search(
    query: string,
    userId: string,
    options: SearchOptions = {}
  ): Promise<SearchResult> {
    const {
      limit = 5,
      filters = {},
      threshold = 0.7
    } = options;

    // 生成查询向量
    const queryVector = await this.generateEmbedding(query);

    // 向量搜索
    const vectorResults = await this.vectorStore.search({
      vector: queryVector,
      filter: { userId, ...filters },
      limit: limit * 2, // 获取更多候选
      threshold
    });

    // 如果启用图数据库，结合图搜索
    let graphResults: any[] = [];
    if (this.graphStore) {
      graphResults = await this.graphStore.findRelated(
        query,
        userId,
        limit
      );
    }

    // 混合排序
    const rankedResults = this.hybridRanking(
      vectorResults,
      graphResults,
      query
    );

    return {
      results: rankedResults.slice(0, limit),
      total: rankedResults.length
    };
  }

  /**
   * 更新记忆
   */
  async update(
    memoryId: string,
    updates: Partial<Memory>
  ): Promise<void> {
    // 获取现有记忆
    const existing = await this.vectorStore.get(memoryId);
    if (!existing) {
      throw new Error(`Memory ${memoryId} not found`);
    }

    // 合并更新
    const updated = { ...existing, ...updates };

    // 重新生成向量（如果内容变化）
    if (updates.content) {
      updated.vector = await this.generateEmbedding(updates.content);
    }

    // 存储
    await this.vectorStore.update(memoryId, updated);

    // 更新图关系
    if (this.graphStore && updates.content) {
      await this.graphStore.updateNode(memoryId, updated);
    }
  }

  /**
   * 删除记忆
   */
  async delete(memoryId: string): Promise<void> {
    await this.vectorStore.delete(memoryId);
    
    if (this.graphStore) {
      await this.graphStore.deleteNode(memoryId);
    }
  }

  /**
   * 获取用户的所有记忆
   */
  async getAll(
    userId: string,
    options: GetAllOptions = {}
  ): Promise<Memory[]> {
    const {
      category,
      startDate,
      endDate,
      limit = 100
    } = options;

    const filters: any = { userId };
    
    if (category) filters.category = category;
    if (startDate) filters.timestamp = { $gte: startDate };
    if (endDate) filters.timestamp = { ...filters.timestamp, $lte: endDate };

    return await this.vectorStore.getAll(filters, limit);
  }

  /**
   * 记忆统计
   */
  async getStats(userId: string): Promise<MemoryStats> {
    const allMemories = await this.getAll(userId, { limit: 10000 });

    const stats: MemoryStats = {
      total: allMemories.length,
      byCategory: {},
      byMonth: {},
      avgConfidence: 0,
      oldestMemory: null,
      newestMemory: null
    };

    let totalConfidence = 0;

    for (const memory of allMemories) {
      // 按类别统计
      stats.byCategory[memory.category] = 
        (stats.byCategory[memory.category] || 0) + 1;

      // 按月份统计
      const month = memory.timestamp.toISOString().substring(0, 7);
      stats.byMonth[month] = (stats.byMonth[month] || 0) + 1;

      // 累加置信度
      totalConfidence += memory.confidence || 0;

      // 更新最老和最新记忆
      if (!stats.oldestMemory || memory.timestamp < stats.oldestMemory) {
        stats.oldestMemory = memory.timestamp;
      }
      if (!stats.newestMemory || memory.timestamp > stats.newestMemory) {
        stats.newestMemory = memory.timestamp;
      }
    }

    stats.avgConfidence = totalConfidence / allMemories.length;

    return stats;
  }

  /**
   * 从消息中提取记忆
   */
  private async extractMemories(message: string): Promise<ExtractedMemory[]> {
    const prompt = `Analyze the following message and extract important information that should be remembered.
Categorize each piece of information as: fact, preference, rule, or summary.

Message: "${message}"

Respond in JSON format:
{
  "memories": [
    {
      "content": "extracted information",
      "category": "fact|preference|rule|summary",
      "confidence": 0.0-1.0
    }
  ]
}`;

    const response = await this.callLLM(prompt);
    const parsed = JSON.parse(response);

    return parsed.memories || [];
  }

  /**
   * 去重记忆
   */
  private async deduplicateMemories(
    memories: ExtractedMemory[],
    userId: string
  ): Promise<ExtractedMemory[]> {
    const unique: ExtractedMemory[] = [];

    for (const memory of memories) {
      // 搜索相似的现有记忆
      const similar = await this.search(memory.content, userId, {
        limit: 1,
        threshold: 0.9
      });

      if (similar.results.length === 0) {
        // 没有相似记忆，保留
        unique.push(memory);
      } else {
        // 有相似记忆，判断是否需要更新
        const existing = similar.results[0];
        if (memory.confidence > existing.confidence) {
          // 新记忆更可信，标记为更新
          await this.update(existing.id, {
            content: memory.content,
            confidence: memory.confidence
          });
        }
      }
    }

    return unique;
  }

  /**
   * 存储记忆
   */
  private async storeMemory(
    memory: ExtractedMemory,
    userId: string,
    metadata?: Record<string, any>
  ): Promise<StoredMemory> {
    const vector = await this.generateEmbedding(memory.content);

    const stored: StoredMemory = {
      id: this.generateId(),
      userId,
      content: memory.content,
      category: memory.category,
      confidence: memory.confidence,
      timestamp: new Date(),
      vector,
      metadata: metadata || {}
    };

    await this.vectorStore.insert(stored);

    return stored;
  }

  /**
   * 更新图关系
   */
  private async updateGraphRelationships(
    memories: StoredMemory[],
    userId: string
  ): Promise<void> {
    if (!this.graphStore) return;

    for (const memory of memories) {
      // 提取实体
      const entities = await this.extractEntities(memory.content);

      // 创建节点
      await this.graphStore.createNode({
        id: memory.id,
        label: 'Memory',
        properties: {
          content: memory.content,
          category: memory.category,
          timestamp: memory.timestamp
        }
      });

      // 创建关系
      for (const entity of entities) {
        await this.graphStore.createRelationship({
          from: memory.id,
          to: entity.id,
          type: entity.relationship,
          properties: {
            confidence: entity.confidence
          }
        });
      }
    }
  }

  /**
   * 混合排序（向量 + 图）
   */
  private hybridRanking(
    vectorResults: any[],
    graphResults: any[],
    query: string
  ): any[] {
    // 创建结果映射
    const resultMap = new Map<string, RankedResult>();

    // 处理向量搜索结果
    vectorResults.forEach((result, index) => {
      resultMap.set(result.id, {
        ...result,
        vectorScore: 1 - (index / vectorResults.length),
        graphScore: 0
      });
    });

    // 处理图搜索结果
    graphResults.forEach((result, index) => {
      const existing = resultMap.get(result.id);
      const graphScore = 1 - (index / graphResults.length);
      
      if (existing) {
        existing.graphScore = graphScore;
      } else {
        resultMap.set(result.id, {
          ...result,
          vectorScore: 0,
          graphScore
        });
      }
    });

    // 计算综合得分并排序
    return Array.from(resultMap.values())
      .map(result => ({
        ...result,
        finalScore: (result.vectorScore * 0.7) + (result.graphScore * 0.3)
      }))
      .sort((a, b) => b.finalScore - a.finalScore);
  }

  // 辅助方法
  private async generateEmbedding(text: string): Promise<number[]> {
    // 调用嵌入模型
    return [];
  }

  private async callLLM(prompt: string): Promise<string> {
    // 调用 LLM
    return "{}";
  }

  private async extractEntities(text: string): Promise<Entity[]> {
    // 提取命名实体
    return [];
  }

  private generateId(): string {
    return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

// 类型定义
interface MemoryAddResult {
  memoriesAdded: number;
  memories: StoredMemory[];
}

interface SearchOptions {
  limit?: number;
  filters?: Record<string, any>;
  threshold?: number;
}

interface SearchResult {
  results: any[];
  total: number;
}

interface GetAllOptions {
  category?: string;
  startDate?: Date;
  endDate?: Date;
  limit?: number;
}

interface MemoryStats {
  total: number;
  byCategory: Record<string, number>;
  byMonth: Record<string, number>;
  avgConfidence: number;
  oldestMemory: Date | null;
  newestMemory: Date | null;
}

interface ExtractedMemory {
  content: string;
  category: 'fact' | 'preference' | 'rule' | 'summary';
  confidence: number;
}

interface StoredMemory extends ExtractedMemory {
  id: string;
  userId: string;
  timestamp: Date;
  vector: number[];
  metadata: Record<string, any>;
}

interface Entity {
  id: string;
  relationship: string;
  confidence: number;
}

interface RankedResult {
  id: string;
  vectorScore: number;
  graphScore: number;
  finalScore?: number;
}

// 使用示例
const memory = new Mem0Memory({
  llmProvider: 'openai',
  apiKey: process.env.OPENAI_API_KEY!,
  vectorDb: {
    type: 'pinecone',
    url: process.env.PINECONE_URL!,
    apiKey: process.env.PINECONE_API_KEY!
  }
});

// 添加记忆
await memory.add(
  "I'm allergic to peanuts and prefer vegetarian food",
  "user_alice"
);

// 搜索记忆
const results = await memory.search(
  "What are my food preferences?",
  "user_alice"
);

console.log(results);

/**
 * 轻量级记忆系统
 */

class SimpleMemorySystem {
  private shortTermMemory: Message[] = [];
  private semanticMemory: Map<string, string> = new Map();
  private episodicMemory: Episode[] = [];
  
  private maxShortTermSize = 10;

  /**
   * 添加消息到短期记忆
   */
  addToShortTerm(message: Message): void {
    this.shortTermMemory.push(message);
    
    if (this.shortTermMemory.length > this.maxShortTermSize) {
      // 移除最旧的消息
      const removed = this.shortTermMemory.shift();
      
      // 提取重要信息到长期记忆
      if (removed) {
        this.consolidateToLongTerm(removed);
      }
    }
  }

  /**
   * 整合到长期记忆
   */
  private consolidateToLongTerm(message: Message): void {
    // 简单的关键词提取
    const keywords = this.extractKeywords(message.content);
    
    for (const keyword of keywords) {
      this.semanticMemory.set(keyword, message.content);
    }
  }

  /**
   * 提取关键词
   */
  private extractKeywords(text: string): string[] {
    // 简化版：分词并过滤停用词
    const stopWords = new Set([
      'the', 'a', 'an', 'and', 'or', 'but', 'is', 'are', 'was', 'were'
    ]);
    
    return text
      .toLowerCase()
      .split(/\W+/)
      .filter(word => word.length > 3 && !stopWords.has(word));
  }

  /**
   * 检索相关记忆
   */
  retrieve(query: string): string[] {
    const keywords = this.extractKeywords(query);
    const results: string[] = [];
    
    for (const keyword of keywords) {
      const memory = this.semanticMemory.get(keyword);
      if (memory && !results.includes(memory)) {
        results.push(memory);
      }
    }
    
    return results;
  }

  /**
   * 获取短期记忆上下文
   */
  getContext(): Message[] {
    return [...this.shortTermMemory];
  }
}

interface Message {
  role: 'user' | 'assistant' | 'system';
  content: string;
  timestamp: Date;
}

// 使用示例
const memorySystem = new SimpleMemorySystem();

memorySystem.addToShortTerm({
  role: 'user',
  content: 'I love playing tennis on weekends',
  timestamp: new Date()
});

memorySystem.addToShortTerm({
  role: 'assistant',
  content: 'That\'s great! Tennis is a wonderful sport.',
  timestamp: new Date()
});

// 检索相关记忆
const relevant = memorySystem.retrieve('sports activities');
console.log(relevant);