memento-mcp-server 0.1.0

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

@@ -0,0 +1,463 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import Database from 'better-sqlite3';
+import { DatabaseUtils } from '../utils/database.js';
+import { getHybridSearchEngine } from '../algorithms/hybrid-search-engine.js';
+import { getVectorSearchEngine } from '../algorithms/vector-search-engine.js';
+import { getPerformanceMonitor } from '../services/performance-monitor.js';
+import { getBatchScheduler } from '../services/batch-scheduler.js';
+import { MemoryEmbeddingService } from '../services/memory-embedding-service.js';
+import { ForgettingPolicyService } from '../services/forgetting-policy-service.js';
+import { MemoryInjectionPrompt } from '../tools/memory-injection-prompt.js';
+
+// Mock external dependencies
+vi.mock('../services/memory-embedding-service.js');
+vi.mock('../services/forgetting-policy-service.js');
+
+describe('Memento M1 통합 테스트', () => {
+  let db: Database.Database;
+  let hybridSearchEngine: any;
+  let vectorSearchEngine: any;
+  let performanceMonitor: any;
+  let batchScheduler: any;
+  let embeddingService: any;
+  let forgettingService: any;
+  let memoryInjectionPrompt: MemoryInjectionPrompt;
+
+  beforeEach(async () => {
+    // Create in-memory database for testing
+    db = new Database(':memory:');
+    
+    // Initialize database schema
+    await DatabaseUtils.initializeDatabase(db);
+    
+    // Initialize services
+    hybridSearchEngine = getHybridSearchEngine();
+    vectorSearchEngine = getVectorSearchEngine();
+    performanceMonitor = getPerformanceMonitor();
+    batchScheduler = getBatchScheduler({
+      cleanupInterval: 1000, // 1초 for testing
+      monitoringInterval: 500, // 0.5초 for testing
+      enableLogging: false
+    });
+    memoryInjectionPrompt = new MemoryInjectionPrompt();
+
+    // Mock embedding service
+    embeddingService = {
+      isAvailable: vi.fn().mockReturnValue(true),
+      generateEmbedding: vi.fn().mockResolvedValue(Array(1536).fill(0.1)),
+      searchBySimilarity: vi.fn().mockResolvedValue([]),
+      getEmbeddingStats: vi.fn().mockResolvedValue({ totalEmbeddings: 0, averageSimilarity: 0 })
+    };
+    vi.mocked(MemoryEmbeddingService).mockImplementation(() => embeddingService);
+
+    // Mock forgetting service
+    forgettingService = {
+      executeMemoryCleanup: vi.fn().mockResolvedValue({
+        softDeleted: [],
+        hardDeleted: [],
+        reviewed: [],
+        totalProcessed: 0
+      })
+    };
+    vi.mocked(ForgettingPolicyService).mockImplementation(() => forgettingService);
+
+    // Initialize vector search engine
+    vectorSearchEngine.initialize(db);
+    
+    // Initialize performance monitor
+    performanceMonitor.initialize(db);
+  });
+
+  afterEach(() => {
+    if (db) {
+      db.close();
+    }
+    batchScheduler.stop();
+    vi.clearAllMocks();
+  });
+
+  describe('데이터베이스 초기화', () => {
+    it('should initialize database with all required tables', () => {
+      const tables = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name NOT LIKE 'sqlite_%'
+      `).all() as { name: string }[];
+
+      const tableNames = tables.map(t => t.name);
+      
+      expect(tableNames).toContain('memory_item');
+      expect(tableNames).toContain('memory_embedding');
+      expect(tableNames).toContain('memory_tag');
+      expect(tableNames).toContain('memory_item_tag');
+      expect(tableNames).toContain('memory_link');
+      expect(tableNames).toContain('feedback_event');
+      expect(tableNames).toContain('wm_buffer');
+    });
+
+    it('should create FTS5 virtual table', () => {
+      const ftsTables = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name LIKE '%_fts'
+      `).all() as { name: string }[];
+
+      expect(ftsTables.some(t => t.name === 'memory_item_fts')).toBe(true);
+    });
+
+    it('should create VSS virtual table', () => {
+      const vssTables = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name LIKE '%_vss'
+      `).all() as { name: string }[];
+
+      expect(vssTables.some(t => t.name === 'memory_item_vec')).toBe(true);
+    });
+  });
+
+  describe('메모리 저장 및 검색 통합', () => {
+    it('should store and retrieve memories through hybrid search', async () => {
+      // 1. 메모리 저장
+      const memoryData = {
+        id: 'test-memory-1',
+        type: 'episodic',
+        content: 'React Hook을 사용한 상태 관리 방법',
+        importance: 0.8,
+        privacy_scope: 'private',
+        created_at: new Date().toISOString(),
+        pinned: false,
+        source: 'test',
+        agent_id: 'test-agent',
+        user_id: 'test-user',
+        project_id: 'test-project'
+      };
+
+      db.prepare(`
+        INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned, source, agent_id, user_id, project_id)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(
+        memoryData.id,
+        memoryData.type,
+        memoryData.content,
+        memoryData.importance,
+        memoryData.privacy_scope,
+        memoryData.created_at,
+        memoryData.pinned ? 1 : 0,
+        memoryData.source,
+        memoryData.agent_id,
+        memoryData.user_id,
+        memoryData.project_id
+      );
+
+      // 2. 하이브리드 검색으로 메모리 검색
+      const searchResult = await hybridSearchEngine.search(db, {
+        query: 'React Hook 상태 관리',
+        limit: 10
+      });
+
+      expect(searchResult.items).toHaveLength(1);
+      expect(searchResult.items[0].content).toContain('React Hook');
+      expect(searchResult.items[0].type).toBe('episodic');
+    });
+
+    it('should handle multiple memory types in search', async () => {
+      // 다양한 타입의 메모리 저장
+      const memories = [
+        {
+          id: 'working-1',
+          type: 'working',
+          content: '현재 작업 중인 React 컴포넌트',
+          importance: 0.6
+        },
+        {
+          id: 'episodic-1',
+          type: 'episodic',
+          content: 'React 프로젝트에서 발생한 버그 해결 경험',
+          importance: 0.8
+        },
+        {
+          id: 'semantic-1',
+          type: 'semantic',
+          content: 'React Hook의 기본 개념과 사용법',
+          importance: 0.9
+        },
+        {
+          id: 'procedural-1',
+          type: 'procedural',
+          content: 'React 컴포넌트 개발 절차',
+          importance: 0.7
+        }
+      ];
+
+      for (const memory of memories) {
+        db.prepare(`
+          INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
+          VALUES (?, ?, ?, ?, 'private', datetime('now'), 0)
+        `).run(memory.id, memory.type, memory.content, memory.importance);
+      }
+
+      // 검색 실행
+      const searchResult = await hybridSearchEngine.search(db, {
+        query: 'React',
+        limit: 10
+      });
+
+      expect(searchResult.items.length).toBeGreaterThan(0);
+      
+      // 모든 메모리 타입이 검색 결과에 포함되는지 확인
+      const resultTypes = searchResult.items.map(item => item.type);
+      expect(resultTypes).toContain('working');
+      expect(resultTypes).toContain('episodic');
+      expect(resultTypes).toContain('semantic');
+      expect(resultTypes).toContain('procedural');
+    });
+  });
+
+  describe('성능 모니터링 통합', () => {
+    it('should collect performance metrics', async () => {
+      const metrics = await performanceMonitor.collectMetrics();
+      
+      expect(metrics).toHaveProperty('timestamp');
+      expect(metrics).toHaveProperty('memory');
+      expect(metrics).toHaveProperty('cpu');
+      expect(metrics).toHaveProperty('database');
+      expect(metrics).toHaveProperty('uptime');
+      
+      expect(metrics.memory).toHaveProperty('rss');
+      expect(metrics.memory).toHaveProperty('heapTotal');
+      expect(metrics.memory).toHaveProperty('heapUsed');
+      expect(metrics.database).toHaveProperty('size');
+      expect(metrics.database).toHaveProperty('memoryCount');
+    });
+
+    it('should detect performance alerts', async () => {
+      // 고메모리 사용량 시뮬레이션
+      const originalMemoryUsage = process.memoryUsage;
+      process.memoryUsage = vi.fn().mockReturnValue({
+        rss: 0,
+        heapTotal: 1000,
+        heapUsed: 900, // 90% 사용률
+        external: 0,
+        arrayBuffers: 0
+      });
+
+      await performanceMonitor.collectMetrics();
+      
+      const alerts = performanceMonitor.getActiveAlerts();
+      expect(alerts.length).toBeGreaterThan(0);
+      
+      const memoryAlert = alerts.find(alert => alert.type === 'memory');
+      expect(memoryAlert).toBeDefined();
+      expect(memoryAlert?.severity).toBe('critical');
+
+      // 원래 함수 복원
+      process.memoryUsage = originalMemoryUsage;
+    });
+  });
+
+  describe('배치 스케줄러 통합', () => {
+    it('should start and stop scheduler correctly', async () => {
+      await batchScheduler.start(db);
+      
+      const status = batchScheduler.getStatus();
+      expect(status.isRunning).toBe(true);
+      expect(status.activeJobs).toContain('cleanup');
+      expect(status.activeJobs).toContain('monitoring');
+
+      batchScheduler.stop();
+      
+      const stoppedStatus = batchScheduler.getStatus();
+      expect(stoppedStatus.isRunning).toBe(false);
+      expect(stoppedStatus.activeJobs).toEqual([]);
+    });
+
+    it('should execute cleanup job', async () => {
+      await batchScheduler.start(db);
+      
+      const result = await batchScheduler.runJob('cleanup');
+      
+      expect(result.jobType).toBe('memory_cleanup');
+      expect(result.success).toBe(true);
+      expect(forgettingService.executeMemoryCleanup).toHaveBeenCalledWith(db);
+    });
+
+    it('should execute monitoring job', async () => {
+      await batchScheduler.start(db);
+      
+      const result = await batchScheduler.runJob('monitoring');
+      
+      expect(result.jobType).toBe('monitoring');
+      expect(result.success).toBe(true);
+      expect(result.details).toHaveProperty('metrics');
+      expect(result.details).toHaveProperty('stats');
+    });
+  });
+
+  describe('메모리 주입 프롬프트 통합', () => {
+    it('should inject memories into prompt', async () => {
+      // 테스트 메모리 저장
+      db.prepare(`
+        INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
+        VALUES ('test-1', 'episodic', 'React Hook 사용법', 0.8, 'private', datetime('now'), 0)
+      `).run();
+
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'React Hook',
+          token_budget: 1000,
+          max_memories: 5
+        },
+        {
+          db,
+          services: { hybridSearchEngine }
+        }
+      );
+
+      expect(result).toHaveProperty('content');
+      expect(result.content[0].type).toBe('text');
+      expect(result.content[0].text).toContain('React Hook');
+    });
+
+    it('should handle empty search results in memory injection', async () => {
+      const result = await memoryInjectionPrompt.execute(
+        {
+          query: 'nonexistent query',
+          token_budget: 1000,
+          max_memories: 5
+        },
+        {
+          db,
+          services: { hybridSearchEngine }
+        }
+      );
+
+      expect(result.content[0].text).toBe('관련 기억을 찾을 수 없습니다.');
+    });
+  });
+
+  describe('벡터 검색 통합', () => {
+    it('should initialize vector search engine', () => {
+      const status = vectorSearchEngine.getIndexStatus();
+      expect(status).toHaveProperty('available');
+      expect(status).toHaveProperty('tableExists');
+      expect(status).toHaveProperty('recordCount');
+    });
+
+    it('should perform vector search when VSS is available', async () => {
+      // VSS 사용 가능하도록 모킹
+      vectorSearchEngine.getIndexStatus = vi.fn().mockReturnValue({
+        available: true,
+        tableExists: true,
+        recordCount: 0
+      });
+
+      const queryVector = Array(1536).fill(0.1);
+      const results = await vectorSearchEngine.search(queryVector, {
+        limit: 10,
+        threshold: 0.5
+      });
+
+      expect(Array.isArray(results)).toBe(true);
+    });
+  });
+
+  describe('에러 처리 통합', () => {
+    it('should handle database connection errors gracefully', async () => {
+      // 데이터베이스 연결 끊기
+      db.close();
+
+      // 성능 모니터링에서 에러 처리 확인
+      const metrics = await performanceMonitor.collectMetrics();
+      expect(metrics.database.memoryCount).toBe(0);
+      expect(metrics.database.size).toBe(0);
+    });
+
+    it('should handle service unavailability', async () => {
+      // 임베딩 서비스 비활성화
+      embeddingService.isAvailable.mockReturnValue(false);
+
+      const searchResult = await hybridSearchEngine.search(db, {
+        query: 'test query',
+        limit: 10
+      });
+
+      // 텍스트 검색만으로도 결과가 나와야 함
+      expect(searchResult).toHaveProperty('items');
+      expect(searchResult).toHaveProperty('total_count');
+    });
+  });
+
+  describe('전체 워크플로우', () => {
+    it('should complete full memory lifecycle', async () => {
+      // 1. 메모리 저장
+      const memoryId = 'workflow-test-1';
+      db.prepare(`
+        INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
+        VALUES (?, 'episodic', '전체 워크플로우 테스트 메모리', 0.9, 'private', datetime('now'), 0)
+      `).run(memoryId);
+
+      // 2. 성능 모니터링 시작
+      performanceMonitor.initialize(db);
+      const metrics = await performanceMonitor.collectMetrics();
+      expect(metrics.database.memoryCount).toBe(1);
+
+      // 3. 배치 스케줄러 시작
+      await batchScheduler.start(db);
+      const status = batchScheduler.getStatus();
+      expect(status.isRunning).toBe(true);
+
+      // 4. 하이브리드 검색
+      const searchResult = await hybridSearchEngine.search(db, {
+        query: '워크플로우 테스트',
+        limit: 10
+      });
+      expect(searchResult.items.length).toBeGreaterThan(0);
+
+      // 5. 메모리 주입
+      const injectionResult = await memoryInjectionPrompt.execute(
+        {
+          query: '워크플로우',
+          token_budget: 500,
+          max_memories: 3
+        },
+        {
+          db,
+          services: { hybridSearchEngine }
+        }
+      );
+      expect(injectionResult.content[0].text).toContain('워크플로우');
+
+      // 6. 정리
+      batchScheduler.stop();
+      expect(batchScheduler.getStatus().isRunning).toBe(false);
+    });
+  });
+
+  describe('동시성 테스트', () => {
+    it('should handle concurrent searches', async () => {
+      // 여러 메모리 저장
+      for (let i = 0; i < 10; i++) {
+        db.prepare(`
+          INSERT INTO memory_item (id, type, content, importance, privacy_scope, created_at, pinned)
+          VALUES (?, 'episodic', '동시성 테스트 메모리 ' + ?, 0.5, 'private', datetime('now'), 0)
+        `).run(`concurrent-${i}`, i);
+      }
+
+      // 동시 검색 실행
+      const searchPromises = Array.from({ length: 5 }, (_, i) =>
+        hybridSearchEngine.search(db, {
+          query: `테스트 ${i}`,
+          limit: 5
+        })
+      );
+
+      const results = await Promise.all(searchPromises);
+      
+      // 모든 검색이 성공해야 함
+      results.forEach(result => {
+        expect(result).toHaveProperty('items');
+        expect(result).toHaveProperty('total_count');
+        expect(Array.isArray(result.items)).toBe(true);
+      });
+    });
+  });
+});
+

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

@@ -0,0 +1,208 @@
+/**
+ * 경량 하이브리드 임베딩 기능 테스트
+ * OpenAI 없이도 임베딩 기능이 동작하는지 확인
+ */
+
+import { createMementoClient } from '../client/index.js';
+
+async function testLightweightEmbeddingFunctionality() {
+  console.log('🧠 경량 하이브리드 임베딩 기능 테스트 시작');
+  
+  const client = createMementoClient();
+  
+  try {
+    // 1. 서버 연결
+    console.log('\n1️⃣ 서버 연결 중...');
+    await client.connect();
+    
+    // 2. 임베딩 서비스 상태 확인
+    console.log('\n2️⃣ 임베딩 서비스 상태 확인');
+    try {
+      const testResult = await client.recall({ query: "test", limit: 1 });
+      console.log('   ✅ 임베딩 서비스 사용 가능');
+    } catch (error) {
+      console.log('   ⚠️ 임베딩 서비스 상태 확인 중 오류:', error);
+    }
+    
+    // 3. 다양한 기억 저장 (경량 임베딩 생성 테스트)
+    console.log('\n3️⃣ 경량 임베딩이 포함된 기억 저장');
+    const memories = [
+      {
+        content: "사용자가 React의 useState Hook에 대해 질문했습니다. 상태 관리를 위한 기본 Hook으로, 함수형 컴포넌트에서 상태를 선언하고 업데이트할 수 있습니다.",
+        type: 'episodic' as const,
+        tags: ['react', 'hooks', 'useState', 'javascript'],
+        importance: 0.9
+      },
+      {
+        content: "TypeScript의 인터페이스와 타입 별칭의 차이점을 설명했습니다. 인터페이스는 확장 가능하고, 타입 별칭은 유니온 타입을 표현할 수 있습니다.",
+        type: 'semantic' as const,
+        tags: ['typescript', 'types', 'interface', 'type-alias'],
+        importance: 0.8
+      },
+      {
+        content: "데이터베이스 인덱싱에 대한 질문을 받았습니다. B-tree 인덱스의 작동 원리와 쿼리 성능에 미치는 영향을 설명했습니다.",
+        type: 'episodic' as const,
+        tags: ['database', 'indexing', 'b-tree', 'performance'],
+        importance: 0.7
+      },
+      {
+        content: "MCP(Model Context Protocol)에 대해 학습했습니다. AI 에이전트와 도구 간의 표준화된 통신 프로토콜로, 확장 가능한 아키텍처를 제공합니다.",
+        type: 'semantic' as const,
+        tags: ['mcp', 'protocol', 'ai', 'architecture'],
+        importance: 0.85
+      },
+      {
+        content: "사용자가 Docker 컨테이너화에 대해 질문했습니다. 이미지 빌드, 레이어 캐싱, 멀티스테이지 빌드 등의 개념을 설명했습니다.",
+        type: 'episodic' as const,
+        tags: ['docker', 'containerization', 'devops', 'deployment'],
+        importance: 0.75
+      }
+    ];
+    
+    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, 50)}...`);
+      
+      // 임베딩 생성 시간을 위해 잠시 대기
+      await new Promise(resolve => setTimeout(resolve, 500));
+    }
+    
+    // 4. 경량 하이브리드 검색 테스트
+    console.log('\n4️⃣ 경량 하이브리드 검색 테스트');
+    
+    const searchQueries = [
+      { query: "React Hook", description: "React Hook 관련 검색" },
+      { query: "타입 시스템", description: "타입 시스템 관련 검색" },
+      { query: "데이터베이스 성능", description: "데이터베이스 성능 관련 검색" },
+      { query: "AI 프로토콜", description: "AI 프로토콜 관련 검색" },
+      { query: "컨테이너 배포", description: "컨테이너 배포 관련 검색" },
+      { query: "상태 관리", description: "상태 관리 관련 검색" },
+      { query: "확장 가능한 아키텍처", description: "아키텍처 관련 검색" }
+    ];
+    
+    for (const { query, description } of searchQueries) {
+      console.log(`\n🔍 ${description}: "${query}"`);
+      try {
+        const startTime = Date.now();
+        const results = await client.recall({ query, limit: 3 });
+        const endTime = Date.now();
+        
+        console.log(`   결과: ${results.length}개 (${endTime - startTime}ms)`);
+        results.forEach((result, index) => {
+          console.log(`   ${index + 1}. [${result.type}] ${result.content.substring(0, 60)}...`);
+          const score = (result as any).finalScore || (result as any).score || 'N/A';
+          console.log(`       점수: ${typeof score === 'number' ? score.toFixed(3) : score}`);
+          if ((result as any).textScore !== undefined && (result as any).vectorScore !== undefined) {
+            console.log(`       텍스트: ${(result as any).textScore.toFixed(3)}, 벡터: ${(result as any).vectorScore.toFixed(3)}`);
+          }
+        });
+      } catch (error) {
+        console.error(`   ❌ 검색 실패: ${error}`);
+      }
+    }
+    
+    // 5. 의미적 유사성 검색 테스트
+    console.log('\n5️⃣ 의미적 유사성 검색 테스트');
+    
+    const semanticQueries = [
+      { query: "프론트엔드 개발", description: "프론트엔드 관련 검색" },
+      { query: "타입 안전성", description: "타입 안전성 관련 검색" },
+      { query: "쿼리 최적화", description: "쿼리 최적화 관련 검색" },
+      { query: "마이크로서비스", description: "마이크로서비스 관련 검색" },
+      { query: "개발 도구", description: "개발 도구 관련 검색" }
+    ];
+    
+    for (const { query, description } of semanticQueries) {
+      console.log(`\n🔍 ${description}: "${query}"`);
+      try {
+        const startTime = Date.now();
+        const results = await client.recall({ query, limit: 2 });
+        const endTime = Date.now();
+        
+        console.log(`   결과: ${results.length}개 (${endTime - startTime}ms)`);
+        results.forEach((result, index) => {
+          console.log(`   ${index + 1}. [${result.type}] ${result.content.substring(0, 60)}...`);
+          const score = (result as any).finalScore || (result as any).score || 'N/A';
+          console.log(`       점수: ${typeof score === 'number' ? score.toFixed(3) : score}`);
+        });
+      } catch (error) {
+        console.error(`   ❌ 검색 실패: ${error}`);
+      }
+    }
+    
+    // 6. 성능 측정
+    console.log('\n6️⃣ 성능 측정');
+    
+    const performanceTests = [
+      "React useState Hook 상태 관리",
+      "TypeScript 인터페이스 타입 시스템",
+      "데이터베이스 B-tree 인덱스 성능",
+      "Docker 컨테이너 이미지 빌드",
+      "MCP 프로토콜 AI 에이전트 통신"
+    ];
+    
+    let totalTime = 0;
+    let successCount = 0;
+    
+    for (const testQuery of performanceTests) {
+      try {
+        const startTime = Date.now();
+        const results = await client.recall({ query: testQuery, limit: 1 });
+        const endTime = Date.now();
+        
+        const duration = endTime - startTime;
+        totalTime += duration;
+        successCount++;
+        
+        console.log(`   "${testQuery}": ${duration}ms (${results.length}개 결과)`);
+      } catch (error) {
+        console.error(`   ❌ "${testQuery}" 실패: ${error}`);
+      }
+    }
+    
+    if (successCount > 0) {
+      const averageTime = totalTime / successCount;
+      console.log(`\n   📊 평균 검색 시간: ${averageTime.toFixed(2)}ms`);
+      console.log(`   📊 성공률: ${(successCount / performanceTests.length * 100).toFixed(1)}%`);
+    }
+    
+    // 7. 임베딩 통계 확인
+    console.log('\n7️⃣ 임베딩 통계 확인');
+    try {
+      const statsResult = await client.recall({ query: "test", limit: 1 });
+      if (statsResult.length > 0 && (statsResult[0] as any).search_type === 'hybrid') {
+        console.log('   ✅ 하이브리드 검색 활성화됨');
+        console.log(`   📊 벡터 검색 사용 가능: ${(statsResult[0] as any).vector_search_available || false}`);
+      }
+    } catch (error) {
+      console.error(`   ❌ 통계 확인 실패: ${error}`);
+    }
+    
+    console.log('\n🎉 경량 하이브리드 임베딩 기능 테스트 완료!');
+    console.log('\n📋 테스트 요약:');
+    console.log('   ✅ 경량 하이브리드 임베딩 서비스 동작 확인');
+    console.log('   ✅ OpenAI 없이도 임베딩 기능 사용 가능');
+    console.log('   ✅ 하이브리드 검색 (텍스트 + 벡터) 동작 확인');
+    console.log('   ✅ 성능 측정 및 통계 수집 완료');
+    
+  } catch (error) {
+    console.error('❌ 테스트 실패:', error);
+  } finally {
+    await client.disconnect();
+  }
+}
+
+// 테스트 실행
+if (process.argv[1] && process.argv[1].endsWith('test-lightweight-embedding.ts')) {
+  testLightweightEmbeddingFunctionality()
+    .then(() => {
+      console.log('✅ 경량 임베딩 테스트 완료');
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error('❌ 경량 임베딩 테스트 실패:', error);
+      process.exit(1);
+    });
+}