memory-lifecycle

You are an expert in memory lifecycle management, consolidation strategies, and efficient memory storage patterns for AI companion systems.

Memory Lifecycle Stages

Memory Creation and Ingestion

// src/services/memoryLifecycle.ts
import { z } from "zod";
import { db } from "../db/client";
import { memories, memoryRelations } from "../db/schema";
import { EmbeddingService } from "./embeddings";
import { sql, and, eq, lt, gte, desc } from "drizzle-orm";

export class MemoryLifecycleService {
  private embeddingService: EmbeddingService;
  
  constructor() {
    this.embeddingService = new EmbeddingService();
  }

  // Intelligent memory creation with deduplication
  async createMemory(input: {
    companionId: string;
    userId: string;
    content: string;
    type: string;
    context?: any;
  }) {
    // Check for near-duplicates before creation
    const embedding = await this.embeddingService.generateEmbedding(input.content);
    
    const duplicates = await this.findNearDuplicates(
      input.companionId,
      input.userId,
      embedding,
      0.95 // 95% similarity threshold
    );
    
    if (duplicates.length > 0) {
      // Consolidate with existing memory instead
      return await this.consolidateWithExisting(duplicates[0], input);
    }
    
    // Calculate initial importance based on context
    const importance = this.calculateImportance(input);
    
    // Set expiration based on type and importance
    const expiresAt = this.calculateExpiration(input.type, importance);
    
    const memory = await db.insert(memories).values({
      ...input,
      embedding,
      importance,
      expiresAt,
      confidence: 1.0,
      accessCount: 0,
      createdAt: new Date(),
      updatedAt: new Date(),
    }).returning();
    
    // Create relationships with existing memories
    await this.establishRelationships(memory[0]);
    
    return memory[0];
  }

  private calculateImportance(input: any): number {
    let importance = 5.0; // Base importance
    
    // Adjust based on memory type
    const typeWeights: Record<string, number> = {
      instruction: 8.0,
      preference: 7.0,
      fact: 6.0,
      experience: 5.0,
      reflection: 4.0,
    };
    
    importance = typeWeights[input.type] || importance;
    
    // Boost for emotional context
    if (input.context?.emotionalTone) {
      const emotionBoost = {
        joy: 1.5,
        sadness: 1.2,
        anger: 1.3,
        fear: 1.4,
        surprise: 1.1,
      };
      importance += emotionBoost[input.context.emotionalTone] || 0;
    }
    
    // Boost for user-marked important
    if (input.context?.userMarkedImportant) {
      importance += 2.0;
    }
    
    return Math.min(10, Math.max(0, importance));
  }
}