memento-mcp-server 0.1.0

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

@@ -0,0 +1,295 @@
+/**
+ * 임베딩 서비스 통합 테스트
+ * 실제 시나리오에서의 동작 검증
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { UnifiedEmbeddingService } from '../services/unified-embedding-service.js';
+import { EmbeddingProviderFactory } from '../services/embedding-provider-factory.js';
+import type { EmbeddingData } from '../types/embedding.types.js';
+
+// 실제 사용 시나리오 데이터
+const memoryItems: EmbeddingData[] = [
+  {
+    id: 'memory-1',
+    content: '사용자가 React Hook에 대해 질문했습니다. useState와 useEffect의 차이점을 설명해주세요.',
+    embedding: []
+  },
+  {
+    id: 'memory-2', 
+    content: 'TypeScript의 타입 시스템에 대한 질문이 있었습니다. 인터페이스와 타입의 차이점을 알고 싶어합니다.',
+    embedding: []
+  },
+  {
+    id: 'memory-3',
+    content: '데이터베이스 최적화에 대한 질문입니다. 인덱스 설계와 쿼리 성능 개선 방법을 문의했습니다.',
+    embedding: []
+  },
+  {
+    id: 'memory-4',
+    content: 'AI 모델 학습에 대한 질문입니다. 과적합 방지와 일반화 성능 향상 방법을 알고 싶어합니다.',
+    embedding: []
+  },
+  {
+    id: 'memory-5',
+    content: '웹 개발에서 보안 관련 질문입니다. XSS와 CSRF 공격 방어 방법에 대해 문의했습니다.',
+    embedding: []
+  }
+];
+
+describe('임베딩 서비스 통합 테스트', () => {
+  let unifiedService: UnifiedEmbeddingService;
+  let factory: EmbeddingProviderFactory;
+
+  beforeAll(async () => {
+    unifiedService = new UnifiedEmbeddingService();
+    factory = EmbeddingProviderFactory.getInstance();
+  });
+
+  afterAll(async () => {
+    // 정리 작업
+  });
+
+  describe('실제 사용 시나리오', () => {
+    it('메모리 아이템 임베딩 생성 및 저장', async () => {
+      console.log('\n📝 메모리 아이템 임베딩 생성 테스트');
+      
+      for (const item of memoryItems) {
+        const result = await unifiedService.generateEmbedding(item.content);
+        
+        expect(result).toBeDefined();
+        expect(result?.embedding).toBeDefined();
+        expect(result?.embedding.length).toBeGreaterThan(0);
+        
+        // 임베딩을 아이템에 저장
+        item.embedding = result!.embedding;
+        
+        console.log(`✅ ${item.id}: ${result?.embedding.length}차원 임베딩 생성 완료`);
+      }
+    });
+
+    it('유사한 메모리 검색', async () => {
+      console.log('\n🔍 유사한 메모리 검색 테스트');
+      
+      const queries = [
+        'React Hook 사용법',
+        'TypeScript 타입 정의',
+        '데이터베이스 성능',
+        '머신러닝 모델',
+        '웹 보안 취약점'
+      ];
+
+      for (const query of queries) {
+        const results = await unifiedService.searchSimilar(query, memoryItems, 3, 0.5);
+        
+        expect(results).toBeDefined();
+        expect(Array.isArray(results)).toBe(true);
+        expect(results.length).toBeGreaterThan(0);
+        
+        console.log(`\n🔍 쿼리: "${query}"`);
+        results.forEach((result, index) => {
+          console.log(`  ${index + 1}. ${result.id} (유사도: ${result.similarity.toFixed(3)})`);
+          console.log(`     내용: ${result.content.substring(0, 50)}...`);
+        });
+      }
+    });
+
+    it('제공자 전환 테스트', async () => {
+      console.log('\n🔄 제공자 전환 테스트');
+      
+      const text = '제공자 전환 테스트를 위한 샘플 텍스트입니다.';
+      
+      // 현재 제공자 확인
+      const currentProvider = unifiedService.getCurrentProviderName();
+      console.log(`현재 제공자: ${currentProvider}`);
+      
+      // 임베딩 생성
+      const result = await unifiedService.generateEmbedding(text);
+      expect(result).toBeDefined();
+      
+      // 사용 가능한 제공자 목록 확인
+      const availableProviders = factory.getAvailableProviders();
+      console.log('사용 가능한 제공자:');
+      availableProviders.forEach(provider => {
+        console.log(`  - ${provider.name}: ${provider.available ? '사용 가능' : '사용 불가'} (우선순위: ${provider.priority})`);
+      });
+    });
+
+    it('에러 처리 및 폴백 테스트', async () => {
+      console.log('\n⚠️ 에러 처리 및 폴백 테스트');
+      
+      // 빈 텍스트 처리
+      try {
+        await unifiedService.generateEmbedding('');
+        expect.fail('빈 텍스트에 대해 에러가 발생해야 합니다');
+      } catch (error) {
+        expect(error).toBeDefined();
+        console.log('✅ 빈 텍스트 에러 처리 확인');
+      }
+      
+      // null 텍스트 처리
+      try {
+        await unifiedService.generateEmbedding(null as any);
+        expect.fail('null 텍스트에 대해 에러가 발생해야 합니다');
+      } catch (error) {
+        expect(error).toBeDefined();
+        console.log('✅ null 텍스트 에러 처리 확인');
+      }
+    });
+
+    it('성능 및 메모리 사용량 모니터링', async () => {
+      console.log('\n📊 성능 및 메모리 사용량 모니터링');
+      
+      const startMemory = process.memoryUsage();
+      const startTime = performance.now();
+      
+      // 대량 임베딩 생성
+      const largeTexts = Array.from({ length: 10 }, (_, i) => 
+        `대량 처리 테스트 텍스트 ${i + 1}. 이것은 성능 테스트를 위한 샘플 텍스트입니다.`
+      );
+      
+      const results = await Promise.all(
+        largeTexts.map(text => unifiedService.generateEmbedding(text))
+      );
+      
+      const endTime = performance.now();
+      const endMemory = process.memoryUsage();
+      
+      const duration = endTime - startTime;
+      const memoryUsed = endMemory.heapUsed - startMemory.heapUsed;
+      
+      console.log(`처리 시간: ${duration.toFixed(2)}ms`);
+      console.log(`메모리 사용량: ${(memoryUsed / 1024 / 1024).toFixed(2)}MB`);
+      console.log(`평균 처리 시간: ${(duration / largeTexts.length).toFixed(2)}ms/텍스트`);
+      
+      expect(results).toHaveLength(largeTexts.length);
+      results.forEach(result => {
+        expect(result).toBeDefined();
+        expect(result?.embedding).toBeDefined();
+      });
+    });
+  });
+
+  describe('제공자별 특성 검증', () => {
+    it('MiniLM 제공자 특성', async () => {
+      console.log('\n🤖 MiniLM 제공자 특성 검증');
+      
+      const text = 'MiniLM 모델은 경량화된 언어 모델입니다.';
+      const result = await unifiedService.generateEmbedding(text);
+      
+      expect(result).toBeDefined();
+      expect(result?.embedding).toHaveLength(384);
+      expect(result?.model).toContain('MiniLM');
+      
+      console.log(`모델: ${result?.model}`);
+      console.log(`차원: ${result?.embedding.length}`);
+      console.log(`토큰 사용량: ${result?.usage.total_tokens}`);
+    });
+
+    it('TF-IDF 제공자 특성', async () => {
+      console.log('\n📊 TF-IDF 제공자 특성 검증');
+      
+      // TF-IDF 서비스를 직접 사용
+      const { LightweightEmbeddingService } = await import('../services/lightweight-embedding-service.js');
+      const tfidfService = new LightweightEmbeddingService();
+      
+      const text = 'TF-IDF는 텍스트 마이닝에서 중요한 기법입니다.';
+      const result = await tfidfService.generateEmbedding(text);
+      
+      expect(result).toBeDefined();
+      expect(result?.embedding).toHaveLength(512);
+      expect(result?.model).toContain('lightweight');
+      
+      console.log(`모델: ${result?.model}`);
+      console.log(`차원: ${result?.embedding.length}`);
+    });
+  });
+
+  describe('실제 사용 패턴 시뮬레이션', () => {
+    it('AI Agent 메모리 저장 시나리오', async () => {
+      console.log('\n🤖 AI Agent 메모리 저장 시나리오');
+      
+      const agentMemories = [
+        '사용자가 React 컴포넌트 생명주기에 대해 질문했습니다.',
+        'TypeScript의 제네릭 사용법에 대한 설명을 요청했습니다.',
+        '데이터베이스 정규화 과정을 설명해달라고 했습니다.',
+        '머신러닝 모델 평가 지표에 대해 문의했습니다.',
+        '웹 애플리케이션 보안 체크리스트를 요청했습니다.'
+      ];
+      
+      const embeddings: EmbeddingData[] = [];
+      
+      for (let i = 0; i < agentMemories.length; i++) {
+        const memory = agentMemories[i];
+        const result = await unifiedService.generateEmbedding(memory);
+        
+        expect(result).toBeDefined();
+        
+        embeddings.push({
+          id: `agent-memory-${i + 1}`,
+          content: memory,
+          embedding: result!.embedding
+        });
+        
+        console.log(`✅ Agent 메모리 ${i + 1} 저장 완료`);
+      }
+      
+      // 관련 메모리 검색
+      const query = 'React와 TypeScript 관련 질문';
+      const similarMemories = await unifiedService.searchSimilar(query, embeddings, 3, 0.3);
+      
+      expect(similarMemories).toBeDefined();
+      expect(similarMemories.length).toBeGreaterThan(0);
+      
+      console.log(`\n🔍 쿼리: "${query}"`);
+      similarMemories.forEach((memory, index) => {
+        console.log(`  ${index + 1}. ${memory.id} (유사도: ${memory.similarity.toFixed(3)})`);
+      });
+    });
+
+    it('대화 컨텍스트 검색 시나리오', async () => {
+      console.log('\n💬 대화 컨텍스트 검색 시나리오');
+      
+      const conversationHistory = [
+        '안녕하세요! React에 대해 질문이 있습니다.',
+        'useState Hook을 사용할 때 주의사항이 있나요?',
+        '네, 의존성 배열을 잘 관리해야 합니다.',
+        'useEffect의 cleanup 함수는 언제 사용하나요?',
+        '컴포넌트가 언마운트될 때 정리 작업을 위해 사용합니다.'
+      ];
+      
+      const conversationEmbeddings: EmbeddingData[] = [];
+      
+      for (let i = 0; i < conversationHistory.length; i++) {
+        const message = conversationHistory[i];
+        const result = await unifiedService.generateEmbedding(message);
+        
+        expect(result).toBeDefined();
+        
+        conversationEmbeddings.push({
+          id: `conv-${i + 1}`,
+          content: message,
+          embedding: result!.embedding
+        });
+      }
+      
+      // 관련 대화 검색
+      const currentQuestion = 'React Hook의 의존성 배열에 대해 더 자세히 알고 싶습니다.';
+      const relevantMessages = await unifiedService.searchSimilar(
+        currentQuestion, 
+        conversationEmbeddings, 
+        5, 
+        0.4
+      );
+      
+      expect(relevantMessages).toBeDefined();
+      expect(relevantMessages.length).toBeGreaterThan(0);
+      
+      console.log(`\n🔍 현재 질문: "${currentQuestion}"`);
+      console.log('관련 대화:');
+      relevantMessages.forEach((message, index) => {
+        console.log(`  ${index + 1}. ${message.content} (유사도: ${message.similarity.toFixed(3)})`);
+      });
+    });
+  });
+});

package/src/test/embedding-performance-benchmark.spec.ts

@@ -0,0 +1,354 @@
+/**
+ * 임베딩 서비스 성능 벤치마크
+ * TF-IDF, MiniLM, OpenAI, Gemini 성능 비교
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { MiniLMEmbeddingService } from '../services/minilm-embedding-service.js';
+import { LightweightEmbeddingService } from '../services/lightweight-embedding-service.js';
+import { UnifiedEmbeddingService } from '../services/unified-embedding-service.js';
+import type { EmbeddingData } from '../types/embedding.types.js';
+
+// 테스트 데이터
+const testTexts = [
+  'Hello world, this is a simple test.',
+  'The quick brown fox jumps over the lazy dog.',
+  'Machine learning and artificial intelligence are transforming the world.',
+  'TypeScript is a strongly typed programming language that builds on JavaScript.',
+  'Memento is an AI memory system that helps agents remember and recall information.',
+  'Vector embeddings are numerical representations of text that capture semantic meaning.',
+  'Natural language processing enables computers to understand human language.',
+  'Deep learning models can process vast amounts of data to find patterns.',
+  'The future of AI lies in creating more efficient and accessible systems.',
+  'Open source software drives innovation in the technology industry.'
+];
+
+// 각 서비스별로 실제 벡터를 생성하므로 고정된 testEmbeddings 제거
+// const testEmbeddings: EmbeddingData[] = testTexts.map((text, index) => ({
+//   id: `test-${index}`,
+//   content: text,
+//   embedding: Array.from({ length: 384 }, () => Math.random())
+// }));
+
+interface BenchmarkResult {
+  provider: string;
+  operation: string;
+  duration: number;
+  success: boolean;
+  error?: string;
+  memoryUsage?: number;
+}
+
+class PerformanceBenchmark {
+  private results: BenchmarkResult[] = [];
+
+  async measureOperation<T>(
+    provider: string,
+    operation: string,
+    fn: () => Promise<T>
+  ): Promise<T | null> {
+    const startTime = performance.now();
+    const startMemory = process.memoryUsage();
+    
+    try {
+      const result = await fn();
+      const endTime = performance.now();
+      const endMemory = process.memoryUsage();
+      
+      this.results.push({
+        provider,
+        operation,
+        duration: endTime - startTime,
+        success: true,
+        memoryUsage: endMemory.heapUsed - startMemory.heapUsed
+      });
+      
+      return result;
+    } catch (error) {
+      const endTime = performance.now();
+      
+      this.results.push({
+        provider,
+        operation,
+        duration: endTime - startTime,
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+      
+      return null;
+    }
+  }
+
+  getResults(): BenchmarkResult[] {
+    return this.results;
+  }
+
+  getSummary(): Record<string, any> {
+    const summary: Record<string, any> = {};
+    
+    // 제공자별 성능 요약
+    const providers = [...new Set(this.results.map(r => r.provider))];
+    
+    for (const provider of providers) {
+      const providerResults = this.results.filter(r => r.provider === provider);
+      const successfulResults = providerResults.filter(r => r.success);
+      
+      summary[provider] = {
+        totalOperations: providerResults.length,
+        successfulOperations: successfulResults.length,
+        successRate: successfulResults.length / providerResults.length,
+        averageDuration: successfulResults.reduce((sum, r) => sum + r.duration, 0) / successfulResults.length,
+        totalMemoryUsage: successfulResults.reduce((sum, r) => sum + (r.memoryUsage || 0), 0),
+        operations: providerResults.map(r => ({
+          operation: r.operation,
+          duration: r.duration,
+          success: r.success,
+          error: r.error
+        }))
+      };
+    }
+    
+    return summary;
+  }
+}
+
+describe('임베딩 서비스 성능 벤치마크', () => {
+  let benchmark: PerformanceBenchmark;
+  let minilmService: MiniLMEmbeddingService;
+  let tfidfService: LightweightEmbeddingService;
+  let unifiedService: UnifiedEmbeddingService;
+
+  beforeAll(async () => {
+    benchmark = new PerformanceBenchmark();
+    minilmService = new MiniLMEmbeddingService();
+    tfidfService = new LightweightEmbeddingService();
+    unifiedService = new UnifiedEmbeddingService();
+  });
+
+  afterAll(() => {
+    // 벤치마크 결과 출력
+    const summary = benchmark.getSummary();
+    console.log('\n📊 임베딩 서비스 성능 벤치마크 결과:');
+    console.log(JSON.stringify(summary, null, 2));
+  });
+
+  describe('MiniLM 임베딩 서비스', () => {
+    it('단일 텍스트 임베딩 생성 성능', async () => {
+      const text = testTexts[0];
+      
+      const result = await benchmark.measureOperation(
+        'minilm',
+        'single-embedding',
+        () => minilmService.generateEmbedding(text)
+      );
+      
+      expect(result).toBeDefined();
+      expect(result?.embedding).toHaveLength(384);
+    });
+
+    it('배치 임베딩 생성 성능', async () => {
+      const promises = testTexts.map(text => 
+        benchmark.measureOperation(
+          'minilm',
+          'batch-embedding',
+          () => minilmService.generateEmbedding(text)
+        )
+      );
+      
+      const results = await Promise.all(promises);
+      
+      expect(results).toHaveLength(testTexts.length);
+      results.forEach(result => {
+        expect(result).toBeDefined();
+        expect(result?.embedding).toHaveLength(384);
+      });
+    });
+
+    it('유사도 검색 성능', async () => {
+      const query = 'artificial intelligence and machine learning';
+      
+      // MiniLM용 실제 벡터 생성
+      const minilmEmbeddings: EmbeddingData[] = [];
+      for (let i = 0; i < testTexts.length; i++) {
+        const result = await minilmService.generateEmbedding(testTexts[i]);
+        if (result) {
+          minilmEmbeddings.push({
+            id: `minilm-test-${i}`,
+            content: testTexts[i],
+            embedding: result.embedding
+          });
+        }
+      }
+      
+      const result = await benchmark.measureOperation(
+        'minilm',
+        'similarity-search',
+        () => minilmService.searchSimilar(query, minilmEmbeddings, 5, 0.7)
+      );
+      
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe('TF-IDF 임베딩 서비스', () => {
+    it('단일 텍스트 임베딩 생성 성능', async () => {
+      const text = testTexts[0];
+      
+      const result = await benchmark.measureOperation(
+        'tfidf',
+        'single-embedding',
+        () => tfidfService.generateEmbedding(text)
+      );
+      
+      expect(result).toBeDefined();
+      expect(result?.embedding).toHaveLength(512);
+    });
+
+    it('배치 임베딩 생성 성능', async () => {
+      const promises = testTexts.map(text => 
+        benchmark.measureOperation(
+          'tfidf',
+          'batch-embedding',
+          () => tfidfService.generateEmbedding(text)
+        )
+      );
+      
+      const results = await Promise.all(promises);
+      
+      expect(results).toHaveLength(testTexts.length);
+      results.forEach(result => {
+        expect(result).toBeDefined();
+        expect(result?.embedding).toHaveLength(512);
+      });
+    });
+
+    it('유사도 검색 성능', async () => {
+      const query = 'artificial intelligence and machine learning';
+      
+      // TF-IDF용 실제 벡터 생성
+      const tfidfEmbeddings: EmbeddingData[] = [];
+      for (let i = 0; i < testTexts.length; i++) {
+        const result = await tfidfService.generateEmbedding(testTexts[i]);
+        if (result) {
+          tfidfEmbeddings.push({
+            id: `tfidf-test-${i}`,
+            content: testTexts[i],
+            embedding: result.embedding
+          });
+        }
+      }
+      
+      const result = await benchmark.measureOperation(
+        'tfidf',
+        'similarity-search',
+        () => tfidfService.searchSimilar(query, tfidfEmbeddings, 5, 0.7)
+      );
+      
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe('통합 임베딩 서비스', () => {
+    it('MiniLM 제공자로 임베딩 생성 성능', async () => {
+      const text = testTexts[0];
+      
+      const result = await benchmark.measureOperation(
+        'unified-minilm',
+        'single-embedding',
+        () => unifiedService.generateEmbedding(text)
+      );
+      
+      expect(result).toBeDefined();
+      // MiniLM은 384차원, TF-IDF는 512차원 - 실제 사용되는 제공자에 따라 다름
+      expect(result?.embedding.length).toBeGreaterThan(0);
+    });
+
+    it('배치 임베딩 생성 성능', async () => {
+      const promises = testTexts.map(text => 
+        benchmark.measureOperation(
+          'unified-minilm',
+          'batch-embedding',
+          () => unifiedService.generateEmbedding(text)
+        )
+      );
+      
+      const results = await Promise.all(promises);
+      
+      expect(results).toHaveLength(testTexts.length);
+      results.forEach(result => {
+        expect(result).toBeDefined();
+        // MiniLM은 384차원, TF-IDF는 512차원 - 실제 사용되는 제공자에 따라 다름
+        expect(result?.embedding.length).toBeGreaterThan(0);
+      });
+    });
+
+    it('유사도 검색 성능', async () => {
+      const query = 'artificial intelligence and machine learning';
+      
+      // 통합 서비스용 실제 벡터 생성 (실제 사용되는 제공자에 맞는 차원)
+      const unifiedEmbeddings: EmbeddingData[] = [];
+      for (let i = 0; i < testTexts.length; i++) {
+        const result = await unifiedService.generateEmbedding(testTexts[i]);
+        if (result) {
+          unifiedEmbeddings.push({
+            id: `unified-test-${i}`,
+            content: testTexts[i],
+            embedding: result.embedding
+          });
+        }
+      }
+      
+      const result = await benchmark.measureOperation(
+        'unified-minilm',
+        'similarity-search',
+        () => unifiedService.searchSimilar(query, unifiedEmbeddings, 5, 0.7)
+      );
+      
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe('성능 비교 분석', () => {
+    it('임베딩 생성 속도 비교', () => {
+      const summary = benchmark.getSummary();
+      
+      // MiniLM vs TF-IDF 속도 비교
+      const minilmAvg = summary['minilm']?.averageDuration || 0;
+      const tfidfAvg = summary['tfidf']?.averageDuration || 0;
+      
+      console.log(`\n⚡ 임베딩 생성 속도 비교:`);
+      console.log(`MiniLM: ${minilmAvg.toFixed(2)}ms`);
+      console.log(`TF-IDF: ${tfidfAvg.toFixed(2)}ms`);
+      
+      // MiniLM이 TF-IDF보다 빠를 것으로 예상
+      expect(minilmAvg).toBeGreaterThan(0);
+      expect(tfidfAvg).toBeGreaterThan(0);
+    });
+
+    it('메모리 사용량 비교', () => {
+      const summary = benchmark.getSummary();
+      
+      const minilmMemory = summary['minilm']?.totalMemoryUsage || 0;
+      const tfidfMemory = summary['tfidf']?.totalMemoryUsage || 0;
+      
+      console.log(`\n💾 메모리 사용량 비교:`);
+      console.log(`MiniLM: ${(minilmMemory / 1024 / 1024).toFixed(2)}MB`);
+      console.log(`TF-IDF: ${(tfidfMemory / 1024 / 1024).toFixed(2)}MB`);
+      
+      expect(minilmMemory).toBeGreaterThan(0);
+      expect(tfidfMemory).toBeGreaterThan(0);
+    });
+
+    it('성공률 확인', () => {
+      const summary = benchmark.getSummary();
+      
+      Object.entries(summary).forEach(([provider, stats]) => {
+        console.log(`\n✅ ${provider} 성공률: ${(stats.successRate * 100).toFixed(1)}%`);
+        expect(stats.successRate).toBeGreaterThan(0.8); // 80% 이상 성공률
+      });
+    });
+  });
+});