memento-mcp-server 0.1.0

package/src/test/test-forgetting.ts

@@ -0,0 +1,162 @@
+/**
+ * 망각 정책 기능 테스트
+ * 망각 알고리즘과 간격 반복 테스트
+ */
+
+import { createMementoClient } from '../client/index.js';
+
+async function testForgettingFunctionality() {
+  console.log('🧠 망각 정책 기능 테스트 시작');
+  
+  const client = createMementoClient();
+  
+  try {
+    // 1. 서버 연결
+    console.log('\n1️⃣ 서버 연결 중...');
+    await client.connect();
+    
+    // 2. 다양한 기억 저장 (망각 테스트용)
+    console.log('\n2️⃣ 망각 테스트용 기억 저장');
+    const memories = [
+      {
+        content: "오래된 작업 기억: 프로젝트 초기 설정 작업을 완료했습니다.",
+        type: 'working' as const,
+        tags: ['old', 'setup', 'completed'],
+        importance: 0.3, // 낮은 중요도
+        source: 'test'
+      },
+      {
+        content: "중요한 에피소드 기억: 사용자가 중요한 질문을 했고, 상세히 답변했습니다.",
+        type: 'episodic' as const,
+        tags: ['important', 'user', 'question'],
+        importance: 0.9, // 높은 중요도
+        source: 'test'
+      },
+      {
+        content: "최근 학습 내용: 새로운 기술 스택에 대해 학습했습니다.",
+        type: 'semantic' as const,
+        tags: ['learning', 'technology', 'recent'],
+        importance: 0.7,
+        source: 'test'
+      },
+      {
+        content: "오래된 프로시저: 특정 작업을 수행하는 방법을 기록했습니다.",
+        type: 'procedural' as const,
+        tags: ['procedure', 'old', 'method'],
+        importance: 0.4, // 중간 중요도
+        source: 'test'
+      },
+      {
+        content: "중복된 내용: 이미 저장된 내용과 유사한 정보입니다.",
+        type: 'episodic' as const,
+        tags: ['duplicate', 'similar'],
+        importance: 0.2, // 낮은 중요도
+        source: 'test'
+      }
+    ];
+    
+    const memoryIds: string[] = [];
+    for (const memory of memories) {
+      const id = await client.remember(memory);
+      memoryIds.push(id);
+      console.log(`✅ 저장됨: ${id.substring(0, 20)}... - ${memory.content.substring(0, 40)}...`);
+      
+      // 시간 간격을 두고 저장 (망각 알고리즘 테스트용)
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    
+    // 3. 망각 통계 조회
+    console.log('\n3️⃣ 망각 통계 조회');
+    try {
+      const stats = await client.callTool('forgetting_stats', {});
+      console.log('📊 망각 통계:');
+      console.log(`   총 메모리: ${stats.stats?.totalMemories || 0}개`);
+      console.log(`   망각 후보: ${stats.stats?.forgetCandidates || 0}개`);
+      console.log(`   리뷰 후보: ${stats.stats?.reviewCandidates || 0}개`);
+      console.log(`   평균 망각 점수: ${stats.stats?.averageForgetScore?.toFixed(3) || 'N/A'}`);
+      console.log(`   메모리 분포:`, stats.stats?.memoryDistribution || {});
+    } catch (error) {
+      console.error(`   ❌ 망각 통계 조회 실패: ${error}`);
+    }
+    
+    // 4. 드라이런 모드로 메모리 정리 테스트
+    console.log('\n4️⃣ 드라이런 모드 메모리 정리 테스트');
+    try {
+      const dryRunResult = await client.callTool('cleanup_memory', { dry_run: true });
+      console.log('🔍 드라이런 분석 결과:');
+      console.log(`   모드: ${dryRunResult.mode}`);
+      console.log(`   총 메모리: ${dryRunResult.stats?.totalMemories || 0}개`);
+      console.log(`   망각 후보: ${dryRunResult.stats?.forgetCandidates || 0}개`);
+      console.log(`   리뷰 후보: ${dryRunResult.stats?.reviewCandidates || 0}개`);
+      console.log(`   평균 망각 점수: ${dryRunResult.stats?.averageForgetScore?.toFixed(3) || 'N/A'}`);
+      console.log(`   메모리 분포:`, dryRunResult.stats?.memoryDistribution || {});
+    } catch (error) {
+      console.error(`   ❌ 드라이런 테스트 실패: ${error}`);
+    }
+    
+    // 5. 실제 메모리 정리 실행 (선택적)
+    console.log('\n5️⃣ 실제 메모리 정리 실행');
+    try {
+      const cleanupResult = await client.callTool('cleanup_memory', { dry_run: false });
+      console.log('🧹 메모리 정리 결과:');
+      console.log(`   모드: ${cleanupResult.mode}`);
+      console.log(`   소프트 삭제: ${cleanupResult.result?.summary?.actualSoftDeletes || 0}개`);
+      console.log(`   하드 삭제: ${cleanupResult.result?.summary?.actualHardDeletes || 0}개`);
+      console.log(`   리뷰 처리: ${cleanupResult.result?.summary?.actualReviews || 0}개`);
+      console.log(`   총 처리: ${cleanupResult.result?.totalProcessed || 0}개`);
+      
+      if (cleanupResult.result?.softDeleted?.length > 0) {
+        console.log(`   소프트 삭제된 메모리: ${cleanupResult.result.softDeleted.join(', ')}`);
+      }
+      if (cleanupResult.result?.hardDeleted?.length > 0) {
+        console.log(`   하드 삭제된 메모리: ${cleanupResult.result.hardDeleted.join(', ')}`);
+      }
+    } catch (error) {
+      console.error(`   ❌ 메모리 정리 실행 실패: ${error}`);
+    }
+    
+    // 6. 정리 후 상태 확인
+    console.log('\n6️⃣ 정리 후 상태 확인');
+    try {
+      const finalStats = await client.callTool('forgetting_stats', {});
+      console.log('📊 정리 후 망각 통계:');
+      console.log(`   총 메모리: ${finalStats.stats?.totalMemories || 0}개`);
+      console.log(`   망각 후보: ${finalStats.stats?.forgetCandidates || 0}개`);
+      console.log(`   평균 망각 점수: ${finalStats.stats?.averageForgetScore?.toFixed(3) || 'N/A'}`);
+    } catch (error) {
+      console.error(`   ❌ 정리 후 통계 조회 실패: ${error}`);
+    }
+    
+    // 7. 남은 메모리 검색 테스트
+    console.log('\n7️⃣ 남은 메모리 검색 테스트');
+    try {
+      const searchResults = await client.recall({ query: "기억", limit: 10 });
+      console.log(`🔍 검색 결과: ${searchResults.length}개`);
+      searchResults.forEach((result, index) => {
+        console.log(`   ${index + 1}. [${result.type}] ${result.content.substring(0, 50)}...`);
+      });
+    } catch (error) {
+      console.error(`   ❌ 검색 테스트 실패: ${error}`);
+    }
+    
+    console.log('\n🎉 망각 정책 기능 테스트 완료!');
+    
+  } catch (error) {
+    console.error('❌ 테스트 실패:', error);
+  } finally {
+    await client.disconnect();
+  }
+}
+
+// 테스트 실행
+if (process.argv[1] && process.argv[1].endsWith('test-forgetting.ts')) {
+  testForgettingFunctionality()
+    .then(() => {
+      console.log('✅ 망각 테스트 완료');
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error('❌ 망각 테스트 실패:', error);
+      process.exit(1);
+    });
+}

package/src/test/test-gemini-embedding.ts

@@ -0,0 +1,159 @@
+/**
+ * Gemini 임베딩 서비스 테스트
+ * Gemini API를 사용한 임베딩 생성 및 검색 기능 테스트
+ */
+
+import { GeminiEmbeddingService } from '../services/gemini-embedding-service.js';
+import { EmbeddingService } from '../services/embedding-service.js';
+import { mementoConfig } from '../config/index.js';
+
+async function testGeminiEmbeddingService() {
+  console.log('🧪 Gemini 임베딩 서비스 테스트 시작\n');
+
+  // 1. Gemini 임베딩 서비스 직접 테스트
+  console.log('1️⃣ Gemini 임베딩 서비스 직접 테스트');
+  const geminiService = new GeminiEmbeddingService();
+  
+  console.log(`   - 서비스 사용 가능: ${geminiService.isAvailable()}`);
+  console.log(`   - 모델 정보:`, geminiService.getModelInfo());
+
+  if (geminiService.isAvailable()) {
+    try {
+      const testText = '안녕하세요! 이것은 Gemini 임베딩 테스트입니다.';
+      console.log(`   - 테스트 텍스트: "${testText}"`);
+      
+      const startTime = Date.now();
+      const result = await geminiService.generateEmbedding(testText);
+      const endTime = Date.now();
+      
+      if (result) {
+        console.log(`   ✅ 임베딩 생성 성공 (${endTime - startTime}ms)`);
+        console.log(`   - 모델: ${result.model}`);
+        console.log(`   - 차원: ${result.embedding.length}`);
+        console.log(`   - 토큰 사용량: ${result.usage.total_tokens}`);
+        console.log(`   - 임베딩 샘플: [${result.embedding.slice(0, 5).map(x => x.toFixed(4)).join(', ')}...]`);
+      } else {
+        console.log('   ❌ 임베딩 생성 실패');
+      }
+    } catch (error) {
+      console.log(`   ❌ Gemini 임베딩 테스트 실패:`, error);
+    }
+  } else {
+    console.log('   ⚠️ Gemini 서비스가 사용 불가능합니다 (API 키 확인 필요)');
+  }
+
+  console.log('\n' + '='.repeat(60) + '\n');
+
+  // 2. 통합 임베딩 서비스 테스트 (Gemini 제공자)
+  console.log('2️⃣ 통합 임베딩 서비스 테스트 (Gemini 제공자)');
+  console.log(`   - 현재 임베딩 제공자: ${mementoConfig.embeddingProvider}`);
+  
+  const embeddingService = new EmbeddingService();
+  console.log(`   - 서비스 사용 가능: ${embeddingService.isAvailable()}`);
+  console.log(`   - 모델 정보:`, embeddingService.getModelInfo());
+
+  if (embeddingService.isAvailable()) {
+    try {
+      const testTexts = [
+        'React와 TypeScript를 사용한 웹 개발',
+        'Node.js 백엔드 API 서버 구축',
+        'SQLite 데이터베이스 설계 및 최적화',
+        'MCP 프로토콜을 활용한 AI 에이전트 개발',
+        '머신러닝과 자연어 처리 기술'
+      ];
+
+      console.log('   - 여러 텍스트 임베딩 생성 테스트:');
+      
+      for (let i = 0; i < testTexts.length; i++) {
+        const text = testTexts[i];
+        const startTime = Date.now();
+        const result = await embeddingService.generateEmbedding(text!);
+        const endTime = Date.now();
+        
+        if (result) {
+          console.log(`     ${i + 1}. "${text}"`);
+          console.log(`        ✅ 성공 (${endTime - startTime}ms, ${result.embedding.length}차원)`);
+        } else {
+          console.log(`     ${i + 1}. "${text}"`);
+          console.log(`        ❌ 실패`);
+        }
+      }
+
+      // 3. 유사도 검색 테스트
+      console.log('\n   - 유사도 검색 테스트:');
+      const query = '웹 개발 프레임워크';
+      console.log(`     쿼리: "${query}"`);
+      
+      const embeddings = [];
+      for (let i = 0; i < testTexts.length; i++) {
+        const result = await embeddingService.generateEmbedding(testTexts[i]!);
+        if (result) {
+          embeddings.push({
+            id: `test-${i + 1}`,
+            content: testTexts[i]!,
+            embedding: result.embedding
+          });
+        }
+      }
+
+      if (embeddings.length > 0) {
+        const similarities = await embeddingService.searchSimilar(
+          query,
+          embeddings,
+          3, // 상위 3개
+          0.5 // 임계값 0.5
+        );
+
+        console.log(`     검색 결과 (${similarities.length}개):`);
+        similarities.forEach((item, index) => {
+          console.log(`       ${index + 1}. "${item.content}" (유사도: ${item.similarity.toFixed(4)})`);
+        });
+      }
+
+    } catch (error) {
+      console.log(`   ❌ 통합 임베딩 서비스 테스트 실패:`, error);
+    }
+  } else {
+    console.log('   ⚠️ 통합 임베딩 서비스가 사용 불가능합니다');
+  }
+
+  console.log('\n' + '='.repeat(60) + '\n');
+
+  // 4. 성능 테스트
+  console.log('3️⃣ 성능 테스트');
+  
+  if (embeddingService.isAvailable()) {
+    const performanceTexts = [
+      '짧은 텍스트',
+      '이것은 좀 더 긴 텍스트입니다. 여러 문장으로 구성되어 있고, 다양한 단어들이 포함되어 있습니다.',
+      '매우 긴 텍스트입니다. ' + '반복되는 내용입니다. '.repeat(50) + '끝입니다.'
+    ];
+
+    for (const text of performanceTexts) {
+      console.log(`   - 텍스트 길이: ${text.length}자`);
+      
+      const times = [];
+      for (let i = 0; i < 3; i++) {
+        const startTime = Date.now();
+        await embeddingService.generateEmbedding(text);
+        const endTime = Date.now();
+        times.push(endTime - startTime);
+      }
+      
+      const avgTime = times.reduce((a, b) => a + b, 0) / times.length;
+      const minTime = Math.min(...times);
+      const maxTime = Math.max(...times);
+      
+      console.log(`     평균: ${avgTime.toFixed(2)}ms, 최소: ${minTime}ms, 최대: ${maxTime}ms`);
+    }
+  }
+
+  console.log('\n🎉 Gemini 임베딩 서비스 테스트 완료!');
+}
+
+// 테스트 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  testGeminiEmbeddingService().catch(console.error);
+}
+
+export { testGeminiEmbeddingService };

package/src/test/test-http-server-v2-simple.ts

@@ -0,0 +1,147 @@
+/**
+ * HTTP 서버 v2 간단한 테스트
+ */
+
+import { startServer, cleanup, __test } from '../server/http-server.js';
+import { initializeDatabase, closeDatabase } from '../database/init.js';
+import { SearchEngine } from '../algorithms/search-engine.js';
+import { HybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
+import { MemoryEmbeddingService } from '../services/memory-embedding-service.js';
+import Database from 'better-sqlite3';
+
+async function testBasicFunctionality() {
+  console.log('🧪 HTTP 서버 v2 간단한 테스트 시작');
+  
+  let testDb: Database.Database | null = null;
+  let serverStarted = false;
+  
+  try {
+    // 1. 테스트 데이터베이스 설정
+    console.log('🗄️ 테스트 데이터베이스 설정 중...');
+    testDb = new Database(':memory:'); // 메모리 데이터베이스 사용
+    
+    // 기본 스키마 생성
+    testDb.exec(`
+      CREATE TABLE memory_item (
+        id TEXT PRIMARY KEY,
+        type TEXT CHECK (type IN ('working','episodic','semantic','procedural')),
+        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,
+        source TEXT,
+        agent_id TEXT,
+        user_id TEXT,
+        project_id TEXT,
+        origin_trace TEXT,
+        tags TEXT
+      );
+    `);
+    
+    // 2. 서버 의존성 설정
+    const searchEngine = new SearchEngine();
+    const hybridSearchEngine = new HybridSearchEngine();
+    const embeddingService = new MemoryEmbeddingService();
+    
+    __test.setTestDependencies({
+      database: testDb,
+      searchEngine,
+      hybridSearchEngine,
+      embeddingService
+    });
+    
+    // 3. 서버 시작
+    console.log('🚀 HTTP 서버 v2 시작 중...');
+    await startServer();
+    serverStarted = true;
+    
+    // 서버 시작 대기
+    console.log('⏳ 서버 시작 대기 중...');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    // 4. 기본 테스트
+    console.log('📋 헬스 체크 테스트...');
+    const healthResponse = await fetch('http://localhost:9001/health');
+    const healthData = await healthResponse.json();
+    
+    if (healthResponse.ok && healthData.status === 'healthy') {
+      console.log('✅ 헬스 체크 성공');
+    } else {
+      throw new Error('헬스 체크 실패');
+    }
+    
+    // 5. 도구 목록 테스트
+    console.log('📋 도구 목록 테스트...');
+    const toolsResponse = await fetch('http://localhost:9001/tools');
+    const toolsData = await toolsResponse.json();
+    
+    if (toolsResponse.ok && toolsData.tools && toolsData.tools.length === 5) {
+      console.log(`✅ 도구 목록 성공 (${toolsData.tools.length}개 도구)`);
+    } else {
+      throw new Error('도구 목록 조회 실패');
+    }
+    
+    // 6. remember 도구 테스트
+    console.log('📝 remember 도구 테스트...');
+    const rememberResponse = await fetch('http://localhost:9001/tools/remember', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        content: 'HTTP 서버 v2 간단한 테스트를 위한 기억입니다.',
+        type: 'episodic',
+        importance: 0.8
+      })
+    });
+    
+    const rememberData = await rememberResponse.json();
+    if (rememberResponse.ok && rememberData.result && rememberData.result.memory_id) {
+      console.log(`✅ remember 성공: ${rememberData.result.memory_id}`);
+    } else {
+      throw new Error('remember 테스트 실패');
+    }
+    
+    // 7. recall 도구 테스트
+    console.log('🔍 recall 도구 테스트...');
+    const recallResponse = await fetch('http://localhost:9001/tools/recall', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        query: 'HTTP 서버 v2',
+        limit: 5
+      })
+    });
+    
+    const recallData = await recallResponse.json();
+    if (recallResponse.ok && recallData.result && recallData.result.items) {
+      console.log(`✅ recall 성공: ${recallData.result.items.length}개 결과`);
+    } else {
+      throw new Error('recall 테스트 실패');
+    }
+    
+    console.log('\n🎉 모든 기본 테스트 통과!');
+    
+  } catch (error) {
+    console.error('\n❌ 테스트 실패:', error);
+    throw error;
+  } finally {
+    // 정리
+    if (serverStarted) {
+      console.log('\n🧹 서버 정리 중...');
+      await cleanup();
+    }
+    
+    if (testDb) {
+      console.log('🗄️ 테스트 데이터베이스 정리 중...');
+      closeDatabase(testDb);
+    }
+    
+    console.log('✅ 테스트 완료');
+  }
+}
+
+// 테스트 실행
+testBasicFunctionality().catch(console.error);
+
+export { testBasicFunctionality };