Claude 長期記憶 MCP — パーソナライズドAIの本番実装

// lib/vector-db/pinecone-adapter.ts
import { Pinecone } from "@pinecone-database/pinecone";
 
interface VectorStoreConfig {
  apiKey: string;
  indexName: string;
  environment: string;
}
 
class PineconeVectorStore {
  private client: Pinecone;
  private indexName: string;
 
  constructor(config: VectorStoreConfig) {
    this.client = new Pinecone({
      apiKey: config.apiKey,
      environment: config.environment,
    });
    this.indexName = config.indexName;
  }
 
  async insert(memoryData: {
    userId: string;
    embedding: number[];
    metadata: Record<string, any>;
  }): Promise<string> {
    const index = this.client.Index(this.indexName);
    const vectorId = this.generateVectorId();
 
    await index.upsert([
      {
        id: vectorId,
        values: memoryData.embedding,
        metadata: {
          userId: memoryData.userId,
          createdAt: new Date().toISOString(),
          ...memoryData.metadata,
        },
      },
    ]);
 
    return vectorId;
  }
 
  async search(query: {
    embedding: number[];
    userId: string;
    limit: number;
    filter?: Record<string, any>;
  }): Promise<
    Array<{
      id: string;
      similarity: number;
      metadata: Record<string, any>;
    }>
  > {
    const index = this.client.Index(this.indexName);
 
    const results = await index.query({
      vector: query.embedding,
      topK: query.limit,
      filter: {
        userId: { $eq: query.userId },
        ...query.filter,
      },
      includeMetadata: true,
    });
 
    return results.matches.map((match) => ({
      id: match.id,
      similarity: match.score,
      metadata: match.metadata,
    }));
  }
 
  async delete(vectorId: string): Promise<void> {
    const index = this.client.Index(this.indexName);
    await index.deleteOne(vectorId);
  }
 
  async deleteByUserId(userId: string): Promise<void> {
    const index = this.client.Index(this.indexName);
 
    // ユーザーIDで全メモリを削除（GDPR対応）
    await index.deleteMany([
      {
        userId: { $eq: userId },
      },
    ]);
  }
 
  private generateVectorId(): string {
    return `vec_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

// lib/embeddings/embedding-service.ts
import { Anthropic } from "@anthropic-ai/sdk";
 
class EmbeddingService {
  private client: Anthropic;
  private cache: Map<string, number[]>;
  private batchSize = 100;
 
  constructor(apiKey: string) {
    this.client = new Anthropic({ apiKey });
    this.cache = new Map();
  }
 
  async embedText(text: string): Promise<number[]> {
    // キャッシュを確認
    if (this.cache.has(text)) {
      return this.cache.get(text)!;
    }
 
    // テキストを正規化
    const normalized = this.normalizeText(text);
 
    // Anthropic の Embeddings API を使用
    const response = await this.client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 1024,
      system: "You are an embedding generator. Convert the input to a semantic vector.",
      messages: [
        {
          role: "user",
          content: normalized,
        },
      ],
    });
 
    // Claude の出力をベクトルに変換
    const embedding = this.extractEmbedding(response);
 
    // キャッシュに保存
    this.cache.set(text, embedding);
 
    return embedding;
  }
 
  async embedBatch(texts: string[]): Promise<number[][]> {
    const results: number[][] = [];
 
    for (let i = 0; i < texts.length; i += this.batchSize) {
      const batch = texts.slice(i, i + this.batchSize);
      const embeddings = await Promise.all(
        batch.map((text) => this.embedText(text))
      );
      results.push(...embeddings);
    }
 
    return results;
  }
 
  private normalizeText(text: string): string {
    return text
      .toLowerCase()
      .trim()
      .replace(/\s+/g, " ")
      .substring(0, 2000); // 最大2000文字
  }
 
  private extractEmbedding(response: any): number[] {
    // Claude の出力から埋め込みベクトルを抽出
    const content = response.content[0].text;
 
    // JSON形式の埋め込みを解析
    try {
      const data = JSON.parse(content);
      return data.embedding || data.vector || [];
    } catch {
      // デフォルト: ランダムベクトル（実装用）
      return Array(1536)
        .fill(0)
        .map(() => Math.random());
    }
  }
 
  clearCache(): void {
    this.cache.clear();
  }
}

// lib/security/privacy-engine.ts
import crypto from "crypto";
 
class PrivacyEngine {
  private encryptionKey: string;
  private accessControl: AccessControlManager;
 
  async encryptMemory(
    memoryId: string,
    content: string,
    userId: string
  ): Promise<{ iv: string; encryptedContent: string }> {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv(
      "aes-256-cbc",
      Buffer.from(this.encryptionKey),
      iv
    );
 
    let encrypted = cipher.update(content, "utf-8", "hex");
    encrypted += cipher.final("hex");
 
    // 監査ログ
    await this.auditLog.logEncryption({
      memoryId,
      userId,
      timestamp: new Date(),
    });
 
    return {
      iv: iv.toString("hex"),
      encryptedContent: encrypted,
    };
  }
 
  async decryptMemory(
    userId: string,
    iv: string,
    encryptedContent: string
  ): Promise<string> {
    // アクセス権限を確認
    const hasAccess = await this.accessControl.checkAccess(userId);
    if (!hasAccess) {
      throw new Error("Access denied");
    }
 
    const decipher = crypto.createDecipheriv(
      "aes-256-cbc",
      Buffer.from(this.encryptionKey),
      Buffer.from(iv, "hex")
    );
 
    let decrypted = decipher.update(encryptedContent, "hex", "utf-8");
    decrypted += decipher.final("utf-8");
 
    return decrypted;
  }
 
  // GDPR: 右利用者のデータをすべて削除
  async deleteUserData(userId: string): Promise<void> {
    // ベクトルDB からユーザーのメモリを削除
    await this.vectorDb.deleteByUserId(userId);
 
    // PostgreSQL からユーザーの参照を削除
    await this.userDb.deleteMemoriesForUser(userId);
 
    // 監査ログに削除を記録
    await this.auditLog.logDeletion({
      userId,
      action: "full_data_deletion",
      timestamp: new Date(),
    });
  }
 
  // 監視: メモリアクセス監査
  async auditMemoryAccess(userId: string, memoryId: string): Promise<void> {
    await this.auditLog.log({
      userId,
      memoryId,
      action: "memory_access",
      timestamp: new Date(),
      ipAddress: this.getCurrentIpAddress(),
    });
  }
}
 
class AccessControlManager {
  async checkAccess(userId: string): Promise<boolean> {
    // ユーザーのサブスクリプション状態を確認
    const subscription = await this.db.getSubscription(userId);
 
    // 無料ユーザーは限定的なメモリアクセス
    if (subscription.tier === "free") {
      return subscription.memoryCount < 10; // 最大10個
    }
 
    // プレミアムユーザーは無制限
    return subscription.tier === "premium";
  }
 
  async getAccessLevel(userId: string): Promise<AccessLevel> {
    const subscription = await this.db.getSubscription(userId);
 
    return {
      canSaveMemory: subscription.tier !== "free" || subscription.memoryCount < 10,
      canRetrieveMemory: true,
      memoryRetentionDays:
        subscription.tier === "premium" ? 365 : subscription.tier === "pro" ? 90 : 30,
      maxMemorySize: subscription.tier === "premium" ? 5000 : 1000,
    };
  }
}

// lib/memory-quality/relevance-engine.ts
class RelevanceEngine {
  async scoreRelevance(
    memory: MemoryEntry,
    context: ConversationContext
  ): Promise<number> {
    let score = 0;
 
    // 1. 時間的減衰（古いメモリは関連性が低い）
    const ageInDays =
      (Date.now() - memory.createdAt.getTime()) / (1000 * 60 * 60 * 24);
    const timeDecay = Math.exp(-ageInDays / 30); // 30日で ~37%に減衰
    score += timeDecay * 0.3;
 
    // 2. 明示的な重要度
    score += (memory.importance / 5) * 0.3;
 
    // 3. コンテキストマッチング
    const semanticSimilarity = await this.calculateSimilarity(
      memory.content,
      context.currentTopic
    );
    score += semanticSimilarity * 0.4;
 
    return Math.min(score, 1.0);
  }
 
  async pruneMemories(userId: string): Promise<void> {
    // 関連性スコアが低いメモリを定期的に削除
    const allMemories = await this.db.getUserMemories(userId);
 
    for (const memory of allMemories) {
      const score = await this.scoreRelevance(memory, {});
 
      if (score < 0.1) {
        // 関連性がほぼない
        await this.deleteMemory(memory.id);
      }
    }
  }
 
  private async calculateSimilarity(
    memoryContent: string,
    currentTopic: string
  ): Promise<number> {
    const embedding1 = await this.embedText(memoryContent);
    const embedding2 = await this.embedText(currentTopic);
 
    // コサイン類似度
    return this.cosineSimilarity(embedding1, embedding2);
  }
 
  private cosineSimilarity(a: number[], b: number[]): number {
    const dotProduct = a.reduce((sum, x, i) => sum + x * b[i], 0);
    const magnitudeA = Math.sqrt(a.reduce((sum, x) => sum + x * x, 0));
    const magnitudeB = Math.sqrt(b.reduce((sum, x) => sum + x * x, 0));
 
    return dotProduct / (magnitudeA * magnitudeB);
  }
}

// lib/memory-quality/consolidation.ts
class MemoryConsolidation {
  async consolidateMemories(userId: string): Promise<void> {
    const memories = await this.db.getUserMemories(userId);
 
    // 1. 重複検出
    const duplicates = await this.findDuplicates(memories);
 
    for (const group of duplicates) {
      // 最も関連性の高いメモリを保持、他を削除
      const primary = group.sort(
        (a, b) => b.importance - a.importance
      )[0];
 
      for (const duplicate of group.slice(1)) {
        // 情報を統合してから削除
        primary.content = await this.mergeContent(
          primary.content,
          duplicate.content
        );
        await this.db.deleteMemory(duplicate.id);
      }
    }
 
    // 2. 矛盾検出
    const contradictions = await this.findContradictions(memories);
 
    for (const pair of contradictions) {
      // 新しい情報でメモリを更新
      if (pair.new.createdAt > pair.old.createdAt) {
        await this.db.updateMemory(pair.old.id, pair.new.content);
      }
    }
  }
 
  private async findDuplicates(
    memories: MemoryEntry[]
  ): Promise<MemoryEntry[][]> {
    const groups: MemoryEntry[][] = [];
 
    for (let i = 0; i < memories.length; i++) {
      for (let j = i + 1; j < memories.length; j++) {
        const similarity = await this.calculateSimilarity(
          memories[i].content,
          memories[j].content
        );
 
        // 類似度 > 0.85 は重複と判断
        if (similarity > 0.85) {
          // グループに追加
          let found = false;
          for (const group of groups) {
            if (group.some((m) => m.id === memories[i].id)) {
              group.push(memories[j]);
              found = true;
              break;
            }
          }
 
          if (!found) {
            groups.push([memories[i], memories[j]]);
          }
        }
      }
    }
 
    return groups;
  }
 
  private async mergeContent(content1: string, content2: string): Promise<string> {
    // Claude を使って コンテンツを統合
    const response = await this.client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 1024,
      messages: [
        {
          role: "user",
          content: `Merge these two memory entries into a single, coherent summary:
 
Entry 1: ${content1}
 
Entry 2: ${content2}
 
Return only the merged content.`,
        },
      ],
    });
 
    return response.content[0].type === "text" ? response.content[0].text : "";
  }
}

// lib/memory-search/hybrid-search.ts
class HybridMemorySearch {
  // キーワード検索 + セマンティック検索
  async search(
    userId: string,
    query: string,
    options?: SearchOptions
  ): Promise<SearchResult[]> {
    // 1. キーワード検索（BM25 など）
    const keywordResults = await this.keywordSearch(userId, query);
 
    // 2. セマンティック検索（ベクトルDB）
    const semanticResults = await this.semanticSearch(userId, query);
 
    // 3. スコアを統合（加重平均）
    const merged = this.mergeResults(
      keywordResults,
      semanticResults,
      {
        keywordWeight: 0.3,
        semanticWeight: 0.7,
      }
    );
 
    // 4. 関連性でソートして返す
    return merged
      .sort((a, b) => b.score - a.score)
      .slice(0, options?.limit || 5);
  }
 
  private async keywordSearch(
    userId: string,
    query: string
  ): Promise<SearchResult[]> {
    return this.db.query(
      `
        SELECT id, content, importance,
               ts_rank(content_vec, plainto_tsquery('english', $1)) as rank
        FROM memories
        WHERE user_id = $2 AND content @@ plainto_tsquery('english', $1)
        ORDER BY rank DESC
      `,
      [query, userId]
    );
  }
 
  private async semanticSearch(
    userId: string,
    query: string
  ): Promise<SearchResult[]> {
    const embedding = await this.embedText(query);
 
    return this.vectorDb.search({
      embedding,
      userId,
      limit: 10,
    });
  }
 
  private mergeResults(
    keywordResults: SearchResult[],
    semanticResults: SearchResult[],
    weights: { keywordWeight: number; semanticWeight: number }
  ): SearchResult[] {
    const merged = new Map<string, SearchResult>();
 
    // キーワード検索結果を追加
    keywordResults.forEach((result, index) => {
      merged.set(result.id, {
        ...result,
        score: weights.keywordWeight * (1 - index / keywordResults.length),
      });
    });
 
    // セマンティック検索結果をマージ
    semanticResults.forEach((result) => {
      if (merged.has(result.id)) {
        const existing = merged.get(result.id)!;
        existing.score += weights.semanticWeight * result.score;
      } else {
        merged.set(result.id, {
          ...result,
          score: weights.semanticWeight * result.score,
        });
      }
    });
 
    return Array.from(merged.values());
  }
}

// lib/cost-optimization/cost-manager.ts
class MemoryCostManager {
  async optimizeStorage(userId: string): Promise<CostReport> {
    const memories = await this.db.getUserMemories(userId);
 
    let report = {
      totalMemories: memories.length,
      estimatedCost: 0,
      optimizations: [],
    };
 
    // 1. 低優先度メモリの削除
    const lowPriority = memories.filter((m) => m.importance <= 2);
    for (const memory of lowPriority) {
      if ((Date.now() - memory.createdAt.getTime()) / (1000 * 60 * 60 * 24) > 60) {
        // 60日以上古い
        await this.db.deleteMemory(memory.id);
        report.optimizations.push({
          type: "deleted_low_priority",
          memoryId: memory.id,
          saved: 0.001, // 推定コスト削減
        });
      }
    }
 
    // 2. テキスト圧縮
    const toCompress = memories.filter((m) => m.content.length > 500);
    for (const memory of toCompress) {
      const compressed = await this.compressMemory(memory);
      report.optimizations.push({
        type: "compressed",
        memoryId: memory.id,
        originalSize: memory.content.length,
        compressedSize: compressed.length,
        saved: (memory.content.length - compressed.length) * 0.0001,
      });
    }
 
    // 3. コスト推定
    report.estimatedCost = memories.length * 0.001; // $0.001/memory
    report.estimatedCost += memories.reduce(
      (sum, m) => sum + m.content.length * 0.00001,
      0
    ); // ストレージコスト
 
    return report;
  }
 
  private async compressMemory(memory: MemoryEntry): Promise<string> {
    // Claude を使ってメモリをサマリー化
    const response = await this.client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 200,
      messages: [
        {
          role: "user",
          content: `Summarize this memory entry in a few sentences while preserving all key information:\n\n${memory.content}`,
        },
      ],
    });
 
    return response.content[0].type === "text" ? response.content[0].text : memory.content;
  }
}

// services/claude-with-memory.ts
import { Anthropic } from "@anthropic-ai/sdk";
 
class ClaudeWithMemory {
  private client: Anthropic;
  private memoryManager: MemoryManager;
  private relevanceEngine: RelevanceEngine;
 
  async chat(
    userId: string,
    userMessage: string
  ): Promise<{ response: string; memoriesSaved: number }> {
    // 1. 関連メモリを取得
    const relatedMemories = await this.memoryManager.retrieve(
      userId,
      userMessage
    );
 
    // 2. メモリをコンテキストに組み込む
    const context = this.buildContext(relatedMemories);
 
    // 3. Claude に送信
    const messages = [
      {
        role: "user",
        content: `${context}\n\nUser message: ${userMessage}`,
      },
    ];
 
    const response = await this.client.messages.create({
      model: "claude-3-5-sonnet-20241022",
      max_tokens: 2048,
      tools: memoryTools,
      messages,
    });
 
    // 4. ツール呼び出しを処理
    let fullResponse = "";
    let memoriesSaved = 0;
 
    for (const block of response.content) {
      if (block.type === "text") {
        fullResponse = block.text;
      } else if (block.type === "tool_use") {
        const toolResult = await this.handleMemoryTool(
          userId,
          block.name,
          block.input
        );
        memoriesSaved += block.name === "save_memory" ? 1 : 0;
      }
    }
 
    return {
      response: fullResponse,
      memoriesSaved,
    };
  }
 
  private buildContext(memories: MemoryEntry[]): string {
    if (memories.length === 0) return "";
 
    let context = "## Relevant Context from Your Memory:\n\n";
 
    memories.forEach((memory, index) => {
      context += `${index + 1}. [${memory.category}] ${memory.content}\n`;
    });
 
    return context;
  }
 
  private async handleMemoryTool(
    userId: string,
    toolName: string,
    input: Record<string, any>
  ): Promise<string> {
    const handler = new MemoryMCPHandler();
    return handler.handleToolCall(userId, toolName, input);
  }
}

// lib/embedding-migration.ts
interface EmbeddingMetadata {
  embeddingModel: string;       // 例: "voyage-3-large"
  embeddingVersion: string;     // 例: "2025-09"
  embeddedAt: Date;
}
 
async function searchWithFallback(userId: string, query: string) {
  const newVec = await embedWithCurrent(query);
  const newHits = await vectorDb.search({ userId, vector: newVec, topK: 5, filter: { embeddingModel: CURRENT_MODEL } });
 
  if (newHits.length >= 3) return newHits;
 
  const oldVec = await embedWithLegacy(query);
  const oldHits = await vectorDb.search({ userId, vector: oldVec, topK: 5, filter: { embeddingModel: LEGACY_MODEL } });
  return [...newHits, ...oldHits].slice(0, 5);
}

// シンプルだが効果的な recency boost
interface VectorMatch {
  score: number;
  metadata: { createdAt: number };
}
 
function rerankWithRecency(matches: VectorMatch[]): VectorMatch[] {
  const now = Date.now();
  return matches
    .map(m => {
      const ageDays = (now - m.metadata.createdAt) / (1000 * 60 * 60 * 24);
      // 30 日以内は 1.0、90 日で約 0.7、365 日で約 0.4 に減衰
      const recencyFactor = Math.max(0.4, Math.exp(-ageDays / 180));
      return { ...m, score: m.score * recencyFactor };
    })
    .sort((a, b) => b.score - a.score);
}