memento-mcp-server 0.1.0

package/scripts/backup-embeddings.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * 임베딩 백업 스크립트
+ * 기존 벡터값을 백업한 후 삭제하고 재생성하는 스크립트
+ */
+
+import Database from 'better-sqlite3';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 데이터베이스 경로 설정
+const dbPath = process.env.DB_PATH || path.join(__dirname, '..', 'data', 'memory.db');
+const backupDir = path.join(__dirname, '..', 'backup');
+const backupFile = path.join(backupDir, `embeddings-backup-${new Date().toISOString().replace(/[:.]/g, '-')}.json`);
+
+async function backupEmbeddings() {
+  console.log('🔄 임베딩 백업 시작...');
+  
+  // 백업 디렉토리 생성
+  if (!fs.existsSync(backupDir)) {
+    fs.mkdirSync(backupDir, { recursive: true });
+  }
+
+  // 데이터베이스 연결
+  const db = new Database(dbPath);
+  
+  try {
+    // 기존 임베딩 데이터 조회
+    const embeddings = 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
+      ORDER BY me.created_at
+    `).all();
+
+    console.log(`📊 발견된 임베딩 개수: ${embeddings.length}`);
+
+    if (embeddings.length === 0) {
+      console.log('⚠️ 백업할 임베딩이 없습니다.');
+      return;
+    }
+
+    // 차원별 통계
+    const dimensionStats = {};
+    embeddings.forEach(emb => {
+      const dim = emb.dim;
+      dimensionStats[dim] = (dimensionStats[dim] || 0) + 1;
+    });
+
+    console.log('📈 차원별 통계:');
+    Object.entries(dimensionStats).forEach(([dim, count]) => {
+      console.log(`  - ${dim}차원: ${count}개`);
+    });
+
+    // 백업 데이터 생성
+    const backupData = {
+      timestamp: new Date().toISOString(),
+      totalEmbeddings: embeddings.length,
+      dimensionStats,
+      embeddings: embeddings.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
+      }))
+    };
+
+    // 백업 파일 저장
+    fs.writeFileSync(backupFile, JSON.stringify(backupData, null, 2));
+    console.log(`✅ 백업 완료: ${backupFile}`);
+
+    // 임베딩 테이블 삭제
+    console.log('🗑️ 기존 임베딩 삭제 중...');
+    const deleteResult = db.prepare('DELETE FROM memory_embedding').run();
+    console.log(`✅ 삭제 완료: ${deleteResult.changes}개 행 삭제`);
+
+    console.log('🎉 백업 및 삭제 완료!');
+    console.log('다음 단계: npm run regenerate-embeddings');
+
+  } catch (error) {
+    console.error('❌ 백업 실패:', error);
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+
+// 스크립트 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  backupEmbeddings().catch(console.error);
+}
+
+export { backupEmbeddings };

package/scripts/check-db-integrity.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Memento 데이터베이스 무결성 검사 스크립트
+ * 사용법: node scripts/check-db-integrity.js
+ */
+
+const Database = require('better-sqlite3');
+const fs = require('fs');
+const path = require('path');
+
+const DB_PATH = './data/memory.db';
+const LOG_PATH = './logs/db-integrity.log';
+
+// 로그 디렉토리 생성
+if (!fs.existsSync('./logs')) {
+  fs.mkdirSync('./logs');
+}
+
+function log(message) {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] ${message}\n`;
+  console.log(message);
+  fs.appendFileSync(LOG_PATH, logMessage);
+}
+
+function checkDatabaseIntegrity() {
+  log('데이터베이스 무결성 검사 시작...');
+  
+  try {
+    // 데이터베이스 파일 존재 확인
+    if (!fs.existsSync(DB_PATH)) {
+      log('❌ 데이터베이스 파일이 존재하지 않습니다.');
+      return false;
+    }
+    
+    // 데이터베이스 연결 테스트
+    const db = new Database(DB_PATH);
+    
+    // PRAGMA integrity_check 실행
+    const integrityResult = db.prepare('PRAGMA integrity_check').get();
+    if (integrityResult.integrity_check !== 'ok') {
+      log(`❌ 데이터베이스 무결성 검사 실패: ${integrityResult.integrity_check}`);
+      db.close();
+      return false;
+    }
+    
+    // 기본 테이블 존재 확인
+    const tables = db.prepare(`
+      SELECT name FROM sqlite_master 
+      WHERE type='table' AND name IN ('memory_item', 'memory_embedding', 'memory_tag')
+    `).all();
+    
+    if (tables.length < 3) {
+      log('❌ 필수 테이블이 누락되었습니다.');
+      db.close();
+      return false;
+    }
+    
+    // 데이터 개수 확인
+    const memoryCount = db.prepare('SELECT COUNT(*) as count FROM memory_item').get();
+    const embeddingCount = db.prepare('SELECT COUNT(*) as count FROM memory_embedding').get();
+    
+    log(`✅ 데이터베이스 무결성 검사 통과`);
+    log(`   - 메모리 아이템: ${memoryCount.count}개`);
+    log(`   - 임베딩: ${embeddingCount.count}개`);
+    log(`   - 테이블: ${tables.length}개`);
+    
+    db.close();
+    return true;
+    
+  } catch (error) {
+    log(`❌ 데이터베이스 검사 중 오류 발생: ${error.message}`);
+    return false;
+  }
+}
+
+function main() {
+  const isHealthy = checkDatabaseIntegrity();
+  
+  if (!isHealthy) {
+    log('🚨 데이터베이스에 문제가 있습니다. 백업에서 복구를 고려하세요.');
+    process.exit(1);
+  } else {
+    log('✅ 데이터베이스가 정상 상태입니다.');
+    process.exit(0);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { checkDatabaseIntegrity };

package/scripts/debug-embeddings.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+/**
+ * 임베딩 디버깅 스크립트
+ * 현재 데이터베이스의 임베딩 상태를 상세히 분석
+ */
+
+import Database from 'better-sqlite3';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+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 debugEmbeddings() {
+  console.log('🔍 임베딩 상태 디버깅 시작...');
+  
+  // 데이터베이스 연결
+  const db = new Database(dbPath);
+  
+  try {
+    // 1. 전체 임베딩 통계
+    console.log('\n📊 전체 임베딩 통계:');
+    const totalStats = db.prepare(`
+      SELECT 
+        COUNT(*) as total_count,
+        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(`- 총 임베딩 개수: ${totalStats.total_count}`);
+    console.log(`- 평균 차원: ${totalStats.avg_dim?.toFixed(1) || 'N/A'}`);
+    console.log(`- 최소 차원: ${totalStats.min_dim || 'N/A'}`);
+    console.log(`- 최대 차원: ${totalStats.max_dim || 'N/A'}`);
+    console.log(`- 고유 차원 수: ${totalStats.unique_dims}`);
+
+    // 2. 차원별 분포
+    console.log('\n📈 차원별 분포:');
+    const dimensionStats = db.prepare(`
+      SELECT 
+        dim,
+        COUNT(*) as count,
+        GROUP_CONCAT(memory_id) as memory_ids
+      FROM memory_embedding
+      GROUP BY dim
+      ORDER BY dim
+    `).all();
+
+    dimensionStats.forEach(stat => {
+      console.log(`- ${stat.dim}차원: ${stat.count}개`);
+      if (stat.count <= 5) {
+        console.log(`  메모리 ID: ${stat.memory_ids}`);
+      }
+    });
+
+    // 3. 모델별 분포
+    console.log('\n🤖 모델별 분포:');
+    const modelStats = db.prepare(`
+      SELECT 
+        model,
+        COUNT(*) as count,
+        AVG(dim) as avg_dim
+      FROM memory_embedding
+      GROUP BY model
+      ORDER BY count DESC
+    `).all();
+
+    modelStats.forEach(stat => {
+      console.log(`- ${stat.model || 'NULL'}: ${stat.count}개 (평균 ${stat.avg_dim?.toFixed(1)}차원)`);
+    });
+
+    // 4. 최근 생성된 임베딩들
+    console.log('\n🕒 최근 생성된 임베딩 (최대 10개):');
+    const recentEmbeddings = db.prepare(`
+      SELECT 
+        memory_id,
+        dim,
+        model,
+        created_at,
+        LENGTH(embedding) as embedding_length
+      FROM memory_embedding
+      ORDER BY created_at DESC
+      LIMIT 10
+    `).all();
+
+    recentEmbeddings.forEach(emb => {
+      console.log(`- ${emb.memory_id}: ${emb.dim}차원, ${emb.model}, ${emb.created_at}`);
+    });
+
+    // 5. 문제가 있는 임베딩 찾기
+    console.log('\n⚠️ 문제가 있을 수 있는 임베딩들:');
+    
+    // 차원이 0인 경우
+    const zeroDim = db.prepare(`
+      SELECT memory_id, dim, model FROM memory_embedding WHERE dim = 0
+    `).all();
+    
+    if (zeroDim.length > 0) {
+      console.log(`- 차원이 0인 임베딩: ${zeroDim.length}개`);
+      zeroDim.forEach(emb => {
+        console.log(`  ${emb.memory_id} (${emb.model})`);
+      });
+    }
+
+    // 차원이 매우 큰 경우 (1536보다 큰 경우)
+    const largeDim = db.prepare(`
+      SELECT memory_id, dim, model FROM memory_embedding WHERE dim > 1536
+    `).all();
+    
+    if (largeDim.length > 0) {
+      console.log(`- 차원이 1536보다 큰 임베딩: ${largeDim.length}개`);
+      largeDim.forEach(emb => {
+        console.log(`  ${emb.memory_id}: ${emb.dim}차원 (${emb.model})`);
+      });
+    }
+
+    // 6. 임베딩 데이터 샘플 확인
+    console.log('\n🔬 임베딩 데이터 샘플 (첫 3개):');
+    const samples = db.prepare(`
+      SELECT 
+        memory_id,
+        dim,
+        model,
+        SUBSTR(embedding, 1, 100) as embedding_preview
+      FROM memory_embedding
+      LIMIT 3
+    `).all();
+
+    samples.forEach((sample, index) => {
+      console.log(`\n샘플 ${index + 1}:`);
+      console.log(`- 메모리 ID: ${sample.memory_id}`);
+      console.log(`- 차원: ${sample.dim}`);
+      console.log(`- 모델: ${sample.model}`);
+      console.log(`- 임베딩 미리보기: ${sample.embedding_preview}...`);
+      
+      // 실제 벡터 길이 확인
+      try {
+        const fullEmbedding = db.prepare(`
+          SELECT embedding FROM memory_embedding WHERE memory_id = ?
+        `).get(sample.memory_id);
+        
+        const vector = JSON.parse(fullEmbedding.embedding);
+        console.log(`- 실제 벡터 길이: ${vector.length}`);
+        console.log(`- 첫 5개 값: [${vector.slice(0, 5).join(', ')}...]`);
+      } catch (error) {
+        console.log(`- 벡터 파싱 오류: ${error.message}`);
+      }
+    });
+
+    // 7. 메모리 아이템과의 연결 상태 확인
+    console.log('\n🔗 메모리 아이템 연결 상태:');
+    const connectionStats = db.prepare(`
+      SELECT 
+        (SELECT COUNT(*) FROM memory_item) as total_memories,
+        (SELECT COUNT(*) FROM memory_embedding) as total_embeddings,
+        (SELECT COUNT(*) FROM memory_item mi 
+         LEFT JOIN memory_embedding me ON mi.id = me.memory_id 
+         WHERE me.memory_id IS NULL) as memories_without_embedding
+    `).get();
+
+    console.log(`- 총 메모리 개수: ${connectionStats.total_memories}`);
+    console.log(`- 총 임베딩 개수: ${connectionStats.total_embeddings}`);
+    console.log(`- 임베딩이 없는 메모리: ${connectionStats.memories_without_embedding}`);
+
+  } catch (error) {
+    console.error('❌ 디버깅 실패:', error);
+    process.exit(1);
+  } finally {
+    db.close();
+  }
+}
+
+// 스크립트 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  debugEmbeddings().catch(console.error);
+}
+
+export { debugEmbeddings };

package/scripts/direct-sql-migration.sql

@@ -0,0 +1,36 @@
+-- 임베딩 데이터 마이그레이션 SQL
+-- 기존 데이터에 메타데이터 추가
+
+-- 1. 기존 데이터 업데이트
+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;
+
+-- 2. 인덱스 생성
+CREATE INDEX IF NOT EXISTS idx_memory_embedding_provider ON memory_embedding(embedding_provider);
+CREATE INDEX IF NOT EXISTS idx_memory_embedding_dimensions ON memory_embedding(dimensions);
+CREATE INDEX IF NOT EXISTS idx_memory_embedding_created_by ON memory_embedding(created_by);
+
+-- 3. 검증 쿼리
+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;
+
+-- 4. 최종 데이터 분포 확인
+SELECT 
+  embedding_provider,
+  dimensions,
+  COUNT(*) as count
+FROM memory_embedding 
+GROUP BY embedding_provider, dimensions
+ORDER BY count DESC;

package/scripts/docker-migration.sh

@@ -0,0 +1,105 @@
+#!/bin/bash
+
+echo "🐳 도커 환경에서 임베딩 데이터 마이그레이션 시작..."
+
+# 1. 백업 생성
+echo "💾 백업 생성 중..."
+cp /app/data/memory.db /app/data/memory-backup-$(date +%s).db
+
+# 2. sqlite-vec 없이 새로운 데이터베이스 생성
+echo "📝 새로운 데이터베이스 생성 중..."
+sqlite3 /app/data/memory-new.db << 'EOF'
+-- 메인 기억 테이블
+CREATE TABLE memory_item (
+  id TEXT PRIMARY KEY,
+  type TEXT CHECK (type IN ('working','episodic','semantic','procedural')) NOT NULL,
+  content TEXT NOT NULL,
+  importance REAL CHECK (importance >= 0 AND importance <= 1) DEFAULT 0.5,
+  privacy_scope TEXT CHECK (privacy_scope IN ('private','team','public')) DEFAULT 'private',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  last_accessed TIMESTAMP,
+  pinned BOOLEAN DEFAULT FALSE,
+  tags TEXT,
+  source TEXT,
+  view_count INTEGER DEFAULT 0,
+  cite_count INTEGER DEFAULT 0,
+  edit_count INTEGER DEFAULT 0
+);
+
+-- 임베딩 저장 테이블 (새로운 컬럼 포함)
+CREATE TABLE memory_embedding (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  memory_id TEXT NOT NULL,
+  embedding TEXT NOT NULL,
+  dim INTEGER NOT NULL,
+  model TEXT,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  embedding_provider TEXT,
+  dimensions INTEGER,
+  created_by TEXT DEFAULT 'migration',
+  FOREIGN KEY (memory_id) REFERENCES memory_item(id) ON DELETE CASCADE,
+  UNIQUE(memory_id)
+);
+
+-- 인덱스 생성
+CREATE INDEX idx_memory_embedding_provider ON memory_embedding(embedding_provider);
+CREATE INDEX idx_memory_embedding_dimensions ON memory_embedding(dimensions);
+CREATE INDEX idx_memory_embedding_created_by ON memory_embedding(created_by);
+EOF
+
+# 3. 데이터 복사
+echo "📊 데이터 복사 중..."
+sqlite3 /app/data/memory-new.db << 'EOF'
+ATTACH DATABASE '/app/data/memory.db' AS source;
+
+-- memory_item 데이터 복사
+INSERT INTO memory_item 
+SELECT * FROM source.memory_item;
+
+-- memory_embedding 데이터 복사 및 메타데이터 추가
+INSERT INTO memory_embedding (memory_id, embedding, dim, model, created_at, embedding_provider, dimensions, created_by)
+SELECT 
+  memory_id,
+  embedding,
+  dim,
+  model,
+  created_at,
+  CASE 
+    WHEN model = 'lightweight-hybrid' THEN 'tfidf'
+    WHEN model IS NULL OR model = '' THEN 'tfidf'
+    ELSE 'unknown'
+  END as embedding_provider,
+  dim as dimensions,
+  'legacy' as created_by
+FROM source.memory_embedding;
+
+DETACH DATABASE source;
+EOF
+
+# 4. 검증
+echo "🔍 마이그레이션 검증 중..."
+sqlite3 /app/data/memory-new.db << 'EOF'
+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;
+
+SELECT 
+  embedding_provider,
+  dimensions,
+  COUNT(*) as count
+FROM memory_embedding 
+GROUP BY embedding_provider, dimensions
+ORDER BY count DESC;
+EOF
+
+# 5. 원본 데이터베이스 교체
+echo "🔄 데이터베이스 교체 중..."
+mv /app/data/memory.db /app/data/memory-old.db
+mv /app/data/memory-new.db /app/data/memory.db
+
+echo "✅ 마이그레이션 완료!"
+echo "💾 백업 파일: /app/data/memory-backup-*.db"
+echo "🔄 롤백이 필요한 경우: mv /app/data/memory-old.db /app/data/memory.db"

package/scripts/fix-migration.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+import Database from 'better-sqlite3';
+import { join } from 'path';
+
+const dbPath = join(process.cwd(), 'data', 'memory.db');
+
+console.log('🔧 마이그레이션 수정 중...');
+
+try {
+  const db = new Database(dbPath);
+  
+  // 1. 현재 상태 확인
+  console.log('📊 현재 상태 확인...');
+  const currentSchema = db.prepare("PRAGMA table_info(memory_embedding)").all();
+  console.log('현재 테이블 구조:');
+  console.table(currentSchema);
+  
+  // 2. 컬럼이 있는지 확인
+  const hasProvider = currentSchema.some(col => col.name === 'embedding_provider');
+  const hasDimensions = currentSchema.some(col => col.name === 'dimensions');
+  const hasCreatedBy = currentSchema.some(col => col.name === 'created_by');
+  
+  console.log(`embedding_provider: ${hasProvider ? '✅' : '❌'}`);
+  console.log(`dimensions: ${hasDimensions ? '✅' : '❌'}`);
+  console.log(`created_by: ${hasCreatedBy ? '✅' : '❌'}`);
+  
+  // 3. 데이터 업데이트 (컬럼이 있는 경우에만)
+  if (hasProvider && hasDimensions && hasCreatedBy) {
+    console.log('🔄 데이터 업데이트 중...');
+    
+    const updateResult = 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
+    `).run();
+    
+    console.log(`✅ ${updateResult.changes}개 레코드 업데이트 완료`);
+    
+    // 4. 인덱스 추가
+    console.log('📝 인덱스 추가 중...');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_provider ON memory_embedding(embedding_provider)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_dimensions ON memory_embedding(dimensions)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_memory_embedding_created_by ON memory_embedding(created_by)');
+    console.log('✅ 인덱스 추가 완료');
+    
+    // 5. 최종 검증
+    console.log('🔍 최종 검증...');
+    const validation = 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('📊 검증 결과:');
+    console.table(validation);
+    
+    // 6. 최종 데이터 분포
+    const finalAnalysis = db.prepare(`
+      SELECT 
+        embedding_provider,
+        dimensions,
+        COUNT(*) as count
+      FROM memory_embedding 
+      GROUP BY embedding_provider, dimensions
+      ORDER BY count DESC
+    `).all();
+    
+    console.log('\n📊 최종 데이터 분포:');
+    console.table(finalAnalysis);
+    
+    console.log('\n🎉 마이그레이션 완료!');
+    
+  } else {
+    console.log('❌ 필요한 컬럼이 없습니다. 스키마를 먼저 업데이트해주세요.');
+  }
+  
+  db.close();
+  
+} catch (error) {
+  console.error('❌ 오류 발생:', error.message);
+  process.exit(1);
+}