AIエージェントのメモリアーキテクチャ：長期記憶の設計と実装

interface Memory {
  id: string;
  type: 'episodic' | 'semantic' | 'procedural';
  content: string;
  embedding: number[];      // ベクトル表現
  importance: number;       // 0.0 〜 1.0
  timestamp: Date;
  lastAccessed: Date;
  accessCount: number;
  metadata: {
    userId?: string;
    sessionId?: string;
    tags: string[];
    source: string;
  };
}

class MemoryManager {
  private vectorStore: VectorDatabase;
  private db: PostgreSQLDatabase;
  private embedder: EmbeddingModel;
 
  async storeMemory(
    content: string,
    type: Memory['type'],
    metadata: Partial<Memory['metadata']>
  ): Promise<Memory> {
    // 1. テキストをベクトルに変換
    const embedding = await this.embedder.embed(content);
    
    // 2. 重要度を計算（長さ・感情・参照回数などから）
    const importance = await this.calculateImportance(content, metadata);
    
    // 3. メモリオブジェクトを作成
    const memory: Memory = {
      id: generateUUID(),
      type,
      content,
      embedding,
      importance,
      timestamp: new Date(),
      lastAccessed: new Date(),
      accessCount: 0,
      metadata: {
        tags: [],
        source: 'agent',
        ...metadata
      }
    };
    
    // 4. ベクトルDBとリレーショナルDBに保存
    await Promise.all([
      this.vectorStore.upsert(memory.id, embedding, { type, importance }),
      this.db.insert('memories', memory)
    ]);
    
    return memory;
  }
}

async recallMemories(
  query: string,
  options: {
    types?: Memory['type'][];
    limit?: number;
    minImportance?: number;
    maxAge?: number;  // 日数
  } = {}
): Promise<Memory[]> {
  // クエリをベクトルに変換
  const queryEmbedding = await this.embedder.embed(query);
  
  // フィルター条件を構築
  const filter = {
    type: options.types ? { $in: options.types } : undefined,
    importance: options.minImportance ? { $gte: options.minImportance } : undefined,
    timestamp: options.maxAge ? {
      $gte: new Date(Date.now() - options.maxAge * 24 * 60 * 60 * 1000)
    } : undefined
  };
  
  // ベクトル類似度検索
  const results = await this.vectorStore.query(
    queryEmbedding,
    options.limit ?? 10,
    filter
  );
  
  // アクセス回数を更新して記憶を強化
  await this.reinforceMemories(results.map(r => r.id));
  
  return results;
}

async calculateImportance(
  content: string,
  metadata: Partial<Memory['metadata']>
): Promise<number> {
  let score = 0.5;  // ベーススコア
  
  // 感情的な内容は重要度が高い
  const emotionalKeywords = ['重要', '緊急', 'エラー', '成功', '失敗', '注意'];
  const emotionalScore = emotionalKeywords.filter(k => content.includes(k)).length * 0.1;
  score += Math.min(emotionalScore, 0.3);
  
  // 長いコンテンツは情報が多い
  const lengthScore = Math.min(content.length / 1000, 0.2);
  score += lengthScore;
  
  // ユーザーが明示的に「覚えておいて」と言った
  if (metadata.tags?.includes('explicit_remember')) {
    score += 0.3;
  }
  
  return Math.min(score, 1.0);
}

async maintainMemoryHealth(): Promise<void> {
  const now = new Date();
  const allMemories = await this.db.query('SELECT * FROM memories');
  
  for (const memory of allMemories) {
    const daysSinceAccess = 
      (now.getTime() - memory.lastAccessed.getTime()) / (1000 * 60 * 60 * 24);
    
    // 忘却曲線: importance = initial_importance * e^(-decay_rate * days)
    const decayRate = memory.type === 'procedural' ? 0.005 : 0.02;
    const decayedImportance = memory.importance * Math.exp(-decayRate * daysSinceAccess);
    
    if (decayedImportance < 0.1) {
      // 重要度が低くなった記憶をアーカイブ
      await this.archiveMemory(memory.id);
    } else if (decayedImportance !== memory.importance) {
      // 重要度を更新
      await this.db.update('memories', memory.id, { importance: decayedImportance });
    }
  }
}

async consolidateMemories(): Promise<void> {
  // 類似した記憶をクラスタリング
  const episodicMemories = await this.db.query(
    'SELECT * FROM memories WHERE type = ? AND importance > ?',
    ['episodic', 0.5]
  );
  
  const clusters = await this.clusterSimilarMemories(episodicMemories);
  
  for (const cluster of clusters) {
    if (cluster.length >= 3) {
      // 複数の類似エピソードから意味記憶を生成
      const summary = await this.generateSemanticMemory(cluster);
      
      await this.storeMemory(
        summary,
        'semantic',
        { tags: ['consolidated', ...extractTags(cluster)], source: 'consolidation' }
      );
      
      // 元のエピソード記憶の重要度を下げる
      for (const memory of cluster) {
        await this.db.update('memories', memory.id, { importance: memory.importance * 0.5 });
      }
    }
  }
}

async buildContextWithMemory(
  userMessage: string,
  userId: string
): Promise<string> {
  // 1. 関連する記憶を検索
  const relevantMemories = await this.recallMemories(userMessage, {
    limit: 10,
    minImportance: 0.3
  });
  
  // 2. 記憶をカテゴリ別に整理
  const episodicContext = relevantMemories
    .filter(m => m.type === 'episodic')
    .map(m => `[過去の出来事] ${m.content}`)
    .join('\n');
    
  const semanticContext = relevantMemories
    .filter(m => m.type === 'semantic')
    .map(m => `[学習した知識] ${m.content}`)
    .join('\n');
    
  const proceduralContext = relevantMemories
    .filter(m => m.type === 'procedural')
    .map(m => `[有効な手順] ${m.content}`)
    .join('\n');
  
  // 3. コンテキストをシステムプロンプトに組み込む
  return `
あなたは以下の記憶を持っています：
 
## 関連する過去の出来事
${episodicContext || '（なし）'}
 
## 学習した知識
${semanticContext || '（なし）'}
 
## 有効な手順・パターン
${proceduralContext || '（なし）'}
 
これらの記憶を参考にして、以下のメッセージに対応してください：
${userMessage}
  `.trim();
}

async processConversationEnd(
  conversation: ConversationTurn[],
  userId: string
): Promise<void> {
  // LLMを使って会話から重要な情報を抽出
  const extractionPrompt = `
以下の会話から、将来の対話に役立つ情報を抽出してください。
各情報について、タイプ（episodic/semantic/procedural）と重要度（0-1）も判定してください。
 
会話：
${conversation.map(t => `${t.role}: ${t.content}`).join('\n')}
 
JSON形式で出力してください：
{
  "memories": [
    {"content": "...", "type": "...", "importance": 0.x}
  ]
}
  `;
  
  const extracted = await this.llm.complete(extractionPrompt);
  const { memories } = JSON.parse(extracted);
  
  for (const memory of memories) {
    await this.storeMemory(memory.content, memory.type, {
      userId,
      tags: ['auto_extracted']
    });
  }
}