memento-mcp-server 0.1.0

package/src/services/unified-embedding-service.ts

@@ -0,0 +1,255 @@
+/**
+ * 통합 임베딩 서비스
+ * 4가지 임베딩 제공자 중 선택하여 사용
+ * 
+ * 클린코드 원칙:
+ * - 단일 책임 원칙: 임베딩 서비스 통합만 담당
+ * - 의존성 역전: 팩토리에 의존
+ * - 전략 패턴: 제공자 선택 로직 분리
+ */
+
+import type { 
+  EmbeddingServiceInterface, 
+  EmbeddingResult, 
+  SimilarityResult, 
+  EmbeddingData,
+  EmbeddingProvider 
+} from '../types/embedding.types.js';
+import { EmbeddingProviderFactory } from './embedding-provider-factory.js';
+
+/**
+ * 통합 임베딩 서비스
+ * 순환 의존성을 방지하기 위해 팩토리 패턴 사용
+ */
+export class UnifiedEmbeddingService implements EmbeddingServiceInterface {
+  private factory: EmbeddingProviderFactory;
+  private currentProvider: EmbeddingServiceInterface | null = null;
+  private fallbackProviders: EmbeddingProvider[] = ['minilm', 'openai', 'gemini', 'tfidf'];
+
+  constructor() {
+    this.factory = EmbeddingProviderFactory.getInstance();
+    console.log('✅ 통합 임베딩 서비스 초기화 완료');
+    console.log(`📋 사용 가능한 제공자: ${this.factory.getAvailableProviders().map(p => p.name).join(', ')}`);
+  }
+
+  /**
+   * 텍스트를 임베딩 벡터로 변환
+   * TDD: 제공자 선택, 폴백 처리, 에러 핸들링
+   */
+  async generateEmbedding(text: string, preferredProvider?: EmbeddingProvider): Promise<EmbeddingResult | null> {
+    this.validateInput(text);
+
+    try {
+      const provider = this.selectProvider(preferredProvider);
+      if (!provider) {
+        throw new Error('사용 가능한 임베딩 제공자가 없습니다');
+      }
+
+      this.currentProvider = provider;
+      const result = await provider.generateEmbedding(text);
+      
+      if (result) {
+        // provider 정보 추가
+        const providerName = this.getCurrentProviderName();
+        result.provider = providerName as EmbeddingProvider;
+        console.log(`✅ 임베딩 생성 완료 (${providerName})`);
+        return result;
+      }
+
+      // 폴백 시도
+      return await this.tryFallbackProviders(text);
+
+    } catch (error) {
+      console.error('❌ 임베딩 생성 실패:', error);
+      
+      // 폴백 시도
+      try {
+        return await this.tryFallbackProviders(text);
+      } catch (fallbackError) {
+        throw new Error(`모든 임베딩 제공자 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    }
+  }
+
+  /**
+   * 쿼리와 유사한 임베딩 검색
+   * TDD: 제공자 선택, 폴백 처리
+   */
+  async searchSimilar(
+    query: string,
+    embeddings: EmbeddingData[],
+    limit: number = 10,
+    threshold: number = 0.7,
+    preferredProvider?: EmbeddingProvider
+  ): Promise<SimilarityResult[]> {
+    this.validateInput(query);
+
+    try {
+      const provider = this.selectProvider(preferredProvider);
+      if (!provider) {
+        throw new Error('사용 가능한 임베딩 제공자가 없습니다');
+      }
+
+      this.currentProvider = provider;
+      const results = await provider.searchSimilar(query, embeddings, limit, threshold);
+      
+      if (results.length > 0) {
+        console.log(`✅ 유사도 검색 완료 (${this.getCurrentProviderName()})`);
+        return results;
+      }
+
+      // 폴백 시도
+      return await this.tryFallbackSearch(query, embeddings, limit, threshold);
+
+    } catch (error) {
+      console.error('❌ 유사도 검색 실패:', error);
+      
+      // 폴백 시도
+      try {
+        return await this.tryFallbackSearch(query, embeddings, limit, threshold);
+      } catch (fallbackError) {
+        console.warn('⚠️ 모든 제공자 실패, 빈 결과 반환');
+        return [];
+      }
+    }
+  }
+
+  /**
+   * 서비스 사용 가능 여부 확인
+   * TDD: 최소 하나의 제공자라도 사용 가능해야 함
+   */
+  isAvailable(): boolean {
+    const availableProviders = this.factory.getAvailableProviders();
+    return availableProviders.some(p => p.available);
+  }
+
+  /**
+   * 현재 사용 중인 모델 정보 반환
+   */
+  getModelInfo(): { model: string; dimensions: number; maxTokens: number } {
+    if (this.currentProvider) {
+      return this.currentProvider.getModelInfo();
+    }
+
+    // 기본값 반환
+    return {
+      model: 'unified-embedding',
+      dimensions: 384,
+      maxTokens: 256
+    };
+  }
+
+  /**
+   * 사용 가능한 제공자 목록 반환
+   */
+  getAvailableProviders(): string[] {
+    return this.factory.getAvailableProviders()
+      .filter(p => p.available)
+      .map(p => p.name);
+  }
+
+  /**
+   * 현재 사용 중인 제공자 이름 반환
+   */
+  getCurrentProviderName(): string {
+    if (!this.currentProvider) {
+      return 'none';
+    }
+
+    try {
+      const availableProviders = this.factory.getAvailableProviders();
+      if (!availableProviders) {
+        return 'unknown';
+      }
+      
+      const current = availableProviders.find(p => 
+        this.factory.getProvider(p.name) === this.currentProvider
+      );
+      
+      return current?.name || 'unknown';
+    } catch (error) {
+      console.error('❌ 현재 제공자 이름 조회 실패:', error);
+      return 'unknown';
+    }
+  }
+
+  /**
+   * 폴백 제공자 설정
+   */
+  setFallbackProviders(providers: EmbeddingProvider[]): void {
+    this.fallbackProviders = providers;
+  }
+
+  /**
+   * 입력 검증
+   * 클린코드: 단일 책임 원칙 - 검증만 담당
+   */
+  private validateInput(text: string): void {
+    if (!text || text.trim().length === 0) {
+      throw new Error('텍스트가 비어있습니다');
+    }
+  }
+
+  /**
+   * 제공자 선택
+   * 클린코드: 단일 책임 원칙 - 선택 로직만 담당
+   */
+  private selectProvider(preferredProvider?: EmbeddingProvider): EmbeddingServiceInterface | null {
+    return this.factory.selectProvider(preferredProvider);
+  }
+
+  /**
+   * 폴백 제공자 시도
+   * 클린코드: 단일 책임 원칙 - 폴백 처리만 담당
+   */
+  private async tryFallbackProviders(text: string): Promise<EmbeddingResult | null> {
+    for (const providerName of this.fallbackProviders) {
+      try {
+        const provider = this.factory.getProvider(providerName);
+        if (provider && provider.isAvailable()) {
+          console.log(`🔄 폴백 시도: ${providerName}`);
+          const result = await provider.generateEmbedding(text);
+          if (result) {
+            this.currentProvider = provider;
+            result.provider = providerName;
+            return result;
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ 폴백 제공자 ${providerName} 실패:`, error);
+        continue;
+      }
+    }
+    
+    throw new Error('모든 폴백 제공자 실패');
+  }
+
+  /**
+   * 폴백 검색 시도
+   */
+  private async tryFallbackSearch(
+    query: string,
+    embeddings: EmbeddingData[],
+    limit: number,
+    threshold: number
+  ): Promise<SimilarityResult[]> {
+    for (const providerName of this.fallbackProviders) {
+      try {
+        const provider = this.factory.getProvider(providerName);
+        if (provider && provider.isAvailable()) {
+          console.log(`🔄 폴백 검색 시도: ${providerName}`);
+          const results = await provider.searchSimilar(query, embeddings, limit, threshold);
+          if (results.length > 0) {
+            this.currentProvider = provider;
+            return results;
+          }
+        }
+      } catch (error) {
+        console.warn(`⚠️ 폴백 검색 제공자 ${providerName} 실패:`, error);
+        continue;
+      }
+    }
+    
+    return [];
+  }
+}

package/src/test/debug-http-v2.ts

@@ -0,0 +1,30 @@
+/**
+ * HTTP 서버 v2 디버그 테스트
+ */
+
+console.log('🚀 HTTP 서버 v2 디버그 테스트 시작');
+
+async function testFetch() {
+  try {
+    console.log('📡 HTTP 요청 테스트 중...');
+    
+    const response = await fetch('http://localhost:9001/health');
+    console.log('📊 응답 상태:', response.status);
+    
+    const data = await response.json();
+    console.log('📋 응답 데이터:', data);
+    
+    if (response.ok && data.status === 'healthy') {
+      console.log('✅ HTTP 요청 성공');
+    } else {
+      console.log('❌ HTTP 요청 실패');
+    }
+  } catch (error) {
+    console.error('❌ HTTP 요청 에러:', error);
+  }
+}
+
+// 테스트 실행
+testFetch().then(() => {
+  console.log('🏁 테스트 완료');
+}).catch(console.error);

package/src/test/embedding-integration-test.spec.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)})`);
+      });
+    });
+  });
+});