memento-mcp-server 0.1.0

package/scripts/fix-vector-dimensions.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+/**
+ * 벡터 차원 통일 스크립트
+ * 모든 임베딩을 삭제하고 현재 설정에 맞는 모델로 재생성
+ */
+
+import Database from 'better-sqlite3';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { EmbeddingService } from '../dist/services/embedding-service.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 데이터베이스 경로 설정
+const dbPath = process.env.DB_PATH || path.join(__dirname, '..', 'data', 'memory.db');
+
+async function fixVectorDimensions() {
+  console.log('🔧 벡터 차원 통일 작업 시작...');
+  
+  // 데이터베이스 연결
+  const db = new Database(dbPath);
+  const embeddingService = new EmbeddingService();
+  
+  try {
+    // 1. 현재 상태 확인
+    console.log('\n📊 현재 상태:');
+    const currentStats = db.prepare(`
+      SELECT 
+        COUNT(*) as total,
+        COUNT(DISTINCT dim) as unique_dims,
+        GROUP_CONCAT(DISTINCT dim) as dimensions
+      FROM memory_embedding
+    `).get();
+
+    console.log(`- 총 임베딩: ${currentStats.total}개`);
+    console.log(`- 고유 차원 수: ${currentStats.unique_dims}개`);
+    console.log(`- 차원들: ${currentStats.dimensions}`);
+
+    // 2. 임베딩 서비스 설정 확인
+    console.log('\n🤖 임베딩 서비스 설정:');
+    const modelInfo = embeddingService.getModelInfo();
+    console.log(`- 모델: ${modelInfo.model}`);
+    console.log(`- 차원: ${modelInfo.dimensions}`);
+    console.log(`- 사용 가능: ${embeddingService.isAvailable()}`);
+
+    if (!embeddingService.isAvailable()) {
+      console.error('❌ 임베딩 서비스가 사용 불가능합니다.');
+      process.exit(1);
+    }
+
+    // 3. 기존 임베딩 백업
+    console.log('\n💾 기존 임베딩 백업 중...');
+    const backupData = db.prepare(`
+      SELECT 
+        me.memory_id,
+        me.embedding,
+        me.dim,
+        me.model,
+        me.created_at,
+        mi.content,
+        mi.type
+      FROM memory_embedding me
+      JOIN memory_item mi ON me.memory_id = mi.id
+    `).all();
+
+    const backupFile = path.join(__dirname, '..', 'backup', `embeddings-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.json`);
+    const fs = await import('fs');
+    
+    if (!fs.existsSync(path.dirname(backupFile))) {
+      fs.mkdirSync(path.dirname(backupFile), { recursive: true });
+    }
+
+    fs.writeFileSync(backupFile, JSON.stringify({
+      timestamp: new Date().toISOString(),
+      totalEmbeddings: backupData.length,
+      embeddings: backupData.map(emb => ({
+        memory_id: emb.memory_id,
+        content: emb.content,
+        type: emb.type,
+        embedding: JSON.parse(emb.embedding),
+        dim: emb.dim,
+        model: emb.model,
+        created_at: emb.created_at
+      }))
+    }, null, 2));
+
+    console.log(`✅ 백업 완료: ${backupFile}`);
+
+    // 4. 기존 임베딩 삭제
+    console.log('\n🗑️ 기존 임베딩 삭제 중...');
+    const deleteResult = db.prepare('DELETE FROM memory_embedding').run();
+    console.log(`✅ 삭제 완료: ${deleteResult.changes}개 행 삭제`);
+
+    // 5. 모든 메모리에 대해 새로운 임베딩 생성
+    console.log('\n🔄 새로운 임베딩 생성 중...');
+    const memories = db.prepare(`
+      SELECT id, content, type, importance, created_at
+      FROM memory_item
+      ORDER BY created_at
+    `).all();
+
+    console.log(`📊 처리할 메모리 개수: ${memories.length}`);
+
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (let i = 0; i < memories.length; i++) {
+      const memory = memories[i];
+      const progress = `[${i + 1}/${memories.length}]`;
+      
+      try {
+        console.log(`${progress} 처리 중: ${memory.id} (${memory.type})`);
+        
+        // 임베딩 생성
+        const embeddingResult = await embeddingService.generateEmbedding(memory.content);
+        
+        if (!embeddingResult) {
+          console.warn(`${progress} ⚠️ 임베딩 생성 실패: ${memory.id}`);
+          errorCount++;
+          continue;
+        }
+
+        // 데이터베이스에 저장
+        db.prepare(`
+          INSERT INTO memory_embedding (memory_id, embedding, dim, model, created_at)
+          VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+        `).run(
+          memory.id,
+          JSON.stringify(embeddingResult.embedding),
+          embeddingResult.embedding.length,
+          embeddingResult.model
+        );
+
+        console.log(`${progress} ✅ 완료: ${memory.id} (${embeddingResult.embedding.length}차원)`);
+        successCount++;
+
+        // API 제한을 위한 대기
+        if (i % 10 === 0 && i > 0) {
+          console.log('⏳ API 제한 대기 중...');
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+      } catch (error) {
+        console.error(`${progress} ❌ 오류: ${memory.id}`, error.message);
+        errorCount++;
+      }
+    }
+
+    // 6. 최종 검증
+    console.log('\n🔍 최종 검증:');
+    const finalStats = db.prepare(`
+      SELECT 
+        COUNT(*) as total,
+        AVG(dim) as avg_dim,
+        MIN(dim) as min_dim,
+        MAX(dim) as max_dim,
+        COUNT(DISTINCT dim) as unique_dims
+      FROM memory_embedding
+    `).get();
+
+    console.log(`- 총 임베딩: ${finalStats.total}개`);
+    console.log(`- 평균 차원: ${finalStats.avg_dim?.toFixed(1) || 'N/A'}`);
+    console.log(`- 최소 차원: ${finalStats.min_dim || 'N/A'}`);
+    console.log(`- 최대 차원: ${finalStats.max_dim || 'N/A'}`);
+    console.log(`- 고유 차원 수: ${finalStats.unique_dims}개`);
+
+    // 차원 일치성 확인
+    const expectedDim = modelInfo.dimensions;
+    const mismatchedDims = db.prepare(`
+      SELECT COUNT(*) as count FROM memory_embedding WHERE dim != ?
+    `).get(expectedDim);
+
+    if (mismatchedDims.count > 0) {
+      console.warn(`⚠️ 차원 불일치 발견: ${mismatchedDims.count}개`);
+    } else {
+      console.log('✅ 모든 임베딩의 차원이 일치합니다!');
+    }
+
+    // 7. 결과 요약
+    console.log('\n📊 작업 완료 요약:');
+    console.log(`✅ 성공: ${successCount}개`);
+    console.log(`❌ 실패: ${errorCount}개`);
+    console.log(`📈 성공률: ${((successCount / memories.length) * 100).toFixed(1)}%`);
+
+    if (finalStats.unique_dims === 1) {
+      console.log('🎉 벡터 차원 통일 완료! 이제 검색이 정상 작동할 것입니다.');
+    } else {
+      console.log('⚠️ 여전히 차원 불일치가 있습니다. 추가 확인이 필요합니다.');
+    }
+
+  } catch (error) {
+    console.error('❌ 벡터 차원 통일 실패:', error);
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+
+// 스크립트 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  fixVectorDimensions().catch(console.error);
+}
+
+export { fixVectorDimensions };

package/scripts/migrate-embedding-data.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * 임베딩 데이터 마이그레이션 스크립트
+ * 기존 임베딩 데이터를 새로운 통합 시스템으로 마이그레이션
+ */
+
+import Database from 'better-sqlite3';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { readFileSync } from 'fs';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+class EmbeddingMigration {
+  constructor() {
+    this.dbPath = join(__dirname, '..', 'data', 'memory.db');
+    this.backupPath = join(__dirname, '..', 'data', `memory-backup-${Date.now()}.db`);
+    this.db = null;
+  }
+
+  /**
+   * 데이터베이스 연결
+   */
+  connect() {
+    try {
+      this.db = new Database(this.dbPath);
+      console.log('✅ 데이터베이스 연결 성공');
+    } catch (error) {
+      console.error('❌ 데이터베이스 연결 실패:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 백업 생성
+   */
+  createBackup() {
+    try {
+      const db = new Database(this.dbPath);
+      db.backup(this.backupPath);
+      db.close();
+      console.log(`✅ 백업 생성 완료: ${this.backupPath}`);
+    } catch (error) {
+      console.error('❌ 백업 생성 실패:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 마이그레이션 실행
+   */
+  async migrate() {
+    try {
+      console.log('🚀 임베딩 데이터 마이그레이션 시작...');
+      
+      // 1. 백업 생성
+      this.createBackup();
+      
+      // 2. 스키마 업데이트
+      await this.updateSchema();
+      
+      // 3. 기존 데이터 분석
+      const analysis = this.analyzeExistingData();
+      console.log('📊 기존 데이터 분석:', analysis);
+      
+      // 4. 데이터 마이그레이션
+      await this.migrateData();
+      
+      // 5. 검증
+      this.validateMigration();
+      
+      console.log('✅ 마이그레이션 완료!');
+      
+    } catch (error) {
+      console.error('❌ 마이그레이션 실패:', error);
+      console.log(`🔄 백업에서 복원하려면: cp ${this.backupPath} ${this.dbPath}`);
+      throw error;
+    } finally {
+      if (this.db) {
+        this.db.close();
+      }
+    }
+  }
+
+  /**
+   * 스키마 업데이트
+   */
+  async updateSchema() {
+    console.log('📝 스키마 업데이트 중...');
+    
+    const migrationPath = join(__dirname, '..', 'src', 'database', 'migrations', '001_add_embedding_metadata.sql');
+    
+    if (!existsSync(migrationPath)) {
+      console.log('📝 마이그레이션 파일이 없어서 직접 실행합니다...');
+      await this.runDirectMigration();
+      return;
+    }
+    
+    const migrationSQL = readFileSync(migrationPath, 'utf8');
+    
+    // SQLite는 ALTER TABLE이 제한적이므로 단계별로 실행
+    const statements = migrationSQL.split(';').filter(stmt => stmt.trim());
+    
+    for (const statement of statements) {
+      if (statement.trim()) {
+        try {
+          this.db.exec(statement);
+        } catch (error) {
+          console.warn(`⚠️ SQL 실행 경고: ${error.message}`);
+        }
+      }
+    }
+    
+    console.log('✅ 스키마 업데이트 완료');
+  }
+
+  /**
+   * 직접 마이그레이션 실행
+   */
+  async runDirectMigration() {
+    try {
+      // 1. 새로운 컬럼 추가
+      console.log('📝 컬럼 추가 중...');
+      this.db.exec('ALTER TABLE memory_embedding ADD COLUMN embedding_provider TEXT');
+      this.db.exec('ALTER TABLE memory_embedding ADD COLUMN dimensions INTEGER');
+      this.db.exec('ALTER TABLE memory_embedding ADD COLUMN created_by TEXT DEFAULT "migration"');
+      
+      // 2. 기존 데이터 업데이트
+      console.log('📝 기존 데이터 업데이트 중...');
+      this.db.exec(`
+        UPDATE memory_embedding 
+        SET 
+          embedding_provider = CASE 
+            WHEN model = 'lightweight-hybrid' THEN 'tfidf'
+            WHEN model IS NULL OR model = '' THEN 'tfidf'
+            ELSE 'unknown'
+          END,
+          dimensions = dim,
+          created_by = 'legacy'
+        WHERE embedding_provider IS NULL
+      `);
+      
+      // 3. 인덱스 추가
+      console.log('📝 인덱스 추가 중...');
+      this.db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_provider ON memory_embedding(embedding_provider)');
+      this.db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_dimensions ON memory_embedding(dimensions)');
+      this.db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_created_by ON memory_embedding(created_by)');
+      
+      console.log('✅ 직접 마이그레이션 완료');
+    } catch (error) {
+      console.error('❌ 직접 마이그레이션 실패:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 기존 데이터 분석
+   */
+  analyzeExistingData() {
+    const analysis = {};
+    
+    // 차원별 분포
+    const dimensionStats = this.db.prepare(`
+      SELECT dim, COUNT(*) as count, 
+             COUNT(CASE WHEN model IS NOT NULL AND model != '' THEN 1 END) as with_model
+      FROM memory_embedding 
+      GROUP BY dim
+    `).all();
+    
+    analysis.dimensions = dimensionStats;
+    
+    // 전체 통계
+    const totalStats = this.db.prepare(`
+      SELECT COUNT(*) as total,
+             COUNT(CASE WHEN embedding_provider IS NOT NULL THEN 1 END) as migrated
+      FROM memory_embedding
+    `).get();
+    
+    analysis.total = totalStats;
+    
+    return analysis;
+  }
+
+  /**
+   * 데이터 마이그레이션
+   */
+  async migrateData() {
+    console.log('🔄 데이터 마이그레이션 중...');
+    
+    // 기존 데이터를 새로운 통합 시스템으로 재생성할지 결정
+    const shouldRegenerate = process.argv.includes('--regenerate');
+    
+    if (shouldRegenerate) {
+      console.log('🔄 기존 임베딩 데이터 재생성 모드');
+      await this.regenerateEmbeddings();
+    } else {
+      console.log('📝 기존 데이터 메타데이터 업데이트 모드');
+      this.updateMetadata();
+    }
+  }
+
+  /**
+   * 메타데이터 업데이트
+   */
+  updateMetadata() {
+    const updateStmt = this.db.prepare(`
+      UPDATE memory_embedding 
+      SET 
+        embedding_provider = CASE 
+          WHEN model = 'lightweight-hybrid' THEN 'tfidf'
+          WHEN model IS NULL OR model = '' THEN 'tfidf'
+          ELSE 'unknown'
+        END,
+        dimensions = dim,
+        created_by = 'legacy'
+      WHERE embedding_provider IS NULL
+    `);
+    
+    const result = updateStmt.run();
+    console.log(`✅ ${result.changes}개 레코드 메타데이터 업데이트 완료`);
+  }
+
+  /**
+   * 임베딩 재생성 (선택사항)
+   */
+  async regenerateEmbeddings() {
+    console.log('⚠️ 임베딩 재생성은 시간이 오래 걸릴 수 있습니다.');
+    console.log('💡 이 기능은 향후 구현 예정입니다.');
+    
+    // TODO: UnifiedEmbeddingService를 사용하여 임베딩 재생성
+    // 1. memory_item에서 content 추출
+    // 2. UnifiedEmbeddingService로 새로운 임베딩 생성
+    // 3. memory_embedding 테이블 업데이트
+  }
+
+  /**
+   * 마이그레이션 검증
+   */
+  validateMigration() {
+    console.log('🔍 마이그레이션 검증 중...');
+    
+    const validation = this.db.prepare(`
+      SELECT 
+        COUNT(*) as total,
+        COUNT(CASE WHEN embedding_provider IS NOT NULL THEN 1 END) as with_provider,
+        COUNT(CASE WHEN dimensions IS NOT NULL THEN 1 END) as with_dimensions,
+        COUNT(CASE WHEN created_by IS NOT NULL THEN 1 END) as with_created_by
+      FROM memory_embedding
+    `).get();
+    
+    console.log('📊 검증 결과:', validation);
+    
+    if (validation.total === validation.with_provider) {
+      console.log('✅ 모든 임베딩에 제공자 정보가 있습니다');
+    } else {
+      console.warn('⚠️ 일부 임베딩에 제공자 정보가 없습니다');
+    }
+  }
+
+  /**
+   * 롤백
+   */
+  rollback() {
+    try {
+      const fs = require('fs');
+      fs.copyFileSync(this.backupPath, this.dbPath);
+      console.log('🔄 백업에서 복원 완료');
+    } catch (error) {
+      console.error('❌ 롤백 실패:', error);
+    }
+  }
+}
+
+// CLI 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const migration = new EmbeddingMigration();
+  
+  const command = process.argv[2];
+  
+  switch (command) {
+    case 'migrate':
+      migration.connect();
+      migration.migrate();
+      break;
+    case 'rollback':
+      migration.rollback();
+      break;
+    case 'analyze':
+      migration.connect();
+      const analysis = migration.analyzeExistingData();
+      console.log('📊 데이터 분석 결과:', JSON.stringify(analysis, null, 2));
+      break;
+    default:
+      console.log(`
+사용법:
+  node migrate-embedding-data.js migrate     # 마이그레이션 실행
+  node migrate-embedding-data.js rollback   # 백업에서 복원
+  node migrate-embedding-data.js analyze    # 데이터 분석만
+  node migrate-embedding-data.js migrate --regenerate  # 임베딩 재생성 모드
+      `);
+  }
+}
+
+export default EmbeddingMigration;

package/scripts/regenerate-embeddings.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+/**
+ * 임베딩 재생성 스크립트
+ * 모든 기억에 대해 새로운 벡터값을 생성하는 스크립트
+ */
+
+import Database from 'better-sqlite3';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { EmbeddingService } from '../dist/services/embedding-service.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 데이터베이스 경로 설정
+const dbPath = process.env.DB_PATH || path.join(__dirname, '..', 'data', 'memory.db');
+
+async function regenerateEmbeddings() {
+  console.log('🔄 임베딩 재생성 시작...');
+  
+  // 데이터베이스 연결
+  const db = new Database(dbPath);
+  const embeddingService = new EmbeddingService();
+  
+  try {
+    // 임베딩 서비스 사용 가능 여부 확인
+    if (!embeddingService.isAvailable()) {
+      console.error('❌ 임베딩 서비스가 사용 불가능합니다.');
+      process.exit(1);
+    }
+
+    // 모델 정보 출력
+    const modelInfo = embeddingService.getModelInfo();
+    console.log(`🤖 사용 모델: ${modelInfo.model} (${modelInfo.dimensions}차원)`);
+
+    // 모든 기억 조회
+    const memories = db.prepare(`
+      SELECT id, content, type, importance, created_at
+      FROM memory_item
+      ORDER BY created_at
+    `).all();
+
+    console.log(`📊 처리할 기억 개수: ${memories.length}`);
+
+    if (memories.length === 0) {
+      console.log('⚠️ 재생성할 기억이 없습니다.');
+      return;
+    }
+
+    let successCount = 0;
+    let errorCount = 0;
+
+    // 각 기억에 대해 임베딩 생성
+    for (let i = 0; i < memories.length; i++) {
+      const memory = memories[i];
+      const progress = `[${i + 1}/${memories.length}]`;
+      
+      try {
+        console.log(`${progress} 처리 중: ${memory.id} (${memory.type})`);
+        
+        // 임베딩 생성
+        const embeddingResult = await embeddingService.generateEmbedding(memory.content);
+        
+        if (!embeddingResult) {
+          console.warn(`${progress} ⚠️ 임베딩 생성 실패: ${memory.id}`);
+          errorCount++;
+          continue;
+        }
+
+        // 데이터베이스에 저장
+        db.prepare(`
+          INSERT OR REPLACE INTO memory_embedding (memory_id, embedding, dim, model, created_at)
+          VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+        `).run(
+          memory.id,
+          JSON.stringify(embeddingResult.embedding),
+          embeddingResult.embedding.length,
+          embeddingResult.model
+        );
+
+        console.log(`${progress} ✅ 완료: ${memory.id} (${embeddingResult.embedding.length}차원)`);
+        successCount++;
+
+        // API 제한을 위한 대기 (필요시)
+        if (i % 10 === 0 && i > 0) {
+          console.log('⏳ API 제한 대기 중...');
+          await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+
+      } catch (error) {
+        console.error(`${progress} ❌ 오류: ${memory.id}`, error.message);
+        errorCount++;
+      }
+    }
+
+    // 결과 통계
+    console.log('\n📊 재생성 완료!');
+    console.log(`✅ 성공: ${successCount}개`);
+    console.log(`❌ 실패: ${errorCount}개`);
+    console.log(`📈 성공률: ${((successCount / memories.length) * 100).toFixed(1)}%`);
+
+    // 최종 검증
+    const finalStats = db.prepare(`
+      SELECT 
+        COUNT(*) as total,
+        AVG(dim) as avg_dim,
+        MIN(dim) as min_dim,
+        MAX(dim) as max_dim
+      FROM memory_embedding
+    `).get();
+
+    console.log('\n🔍 최종 검증:');
+    console.log(`- 총 임베딩 개수: ${finalStats.total}`);
+    console.log(`- 평균 차원: ${finalStats.avg_dim?.toFixed(1) || 'N/A'}`);
+    console.log(`- 최소 차원: ${finalStats.min_dim || 'N/A'}`);
+    console.log(`- 최대 차원: ${finalStats.max_dim || 'N/A'}`);
+
+    // 차원 일치성 확인
+    const expectedDim = modelInfo.dimensions;
+    const mismatchedDims = db.prepare(`
+      SELECT COUNT(*) as count FROM memory_embedding WHERE dim != ?
+    `).get(expectedDim);
+
+    if (mismatchedDims.count > 0) {
+      console.warn(`⚠️ 차원 불일치 발견: ${mismatchedDims.count}개`);
+    } else {
+      console.log('✅ 모든 임베딩의 차원이 일치합니다!');
+    }
+
+  } catch (error) {
+    console.error('❌ 재생성 실패:', error);
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+
+// 스크립트 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  regenerateEmbeddings().catch(console.error);
+}
+
+export { regenerateEmbeddings };