memento-mcp-server 1.6.0 → 1.7.2

package/src/services/memory-embedding-service.spec.ts

@@ -1,417 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { MemoryEmbeddingService, MemoryEmbedding, VectorSearchResult } from './memory-embedding-service.js';
-import { UnifiedEmbeddingService } from './unified-embedding-service.js';
-import { DatabaseUtils } from '../utils/database.js';
-import type { MemoryType } from '../types/index.js';
-
-// Mock dependencies
-vi.mock('./unified-embedding-service.js', () => ({
-  UnifiedEmbeddingService: vi.fn().mockImplementation(() => ({
-    isAvailable: vi.fn(() => true),
-    generateEmbedding: vi.fn(),
-    searchSimilar: vi.fn(),
-    getModelInfo: vi.fn(() => ({
-      model: 'unified-embedding',
-      dimensions: 768,
-      maxTokens: 2048
-    }))
-  }))
-}));
-
-vi.mock('../utils/database.js', () => ({
-  DatabaseUtils: {
-    run: vi.fn(),
-    all: vi.fn()
-  }
-}));
-
-describe('MemoryEmbeddingService', () => {
-  let service: MemoryEmbeddingService;
-  let mockDb: any;
-  let mockEmbeddingService: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    
-    mockDb = {} as any;
-    service = new MemoryEmbeddingService();
-    mockEmbeddingService = (service as any).embeddingService;
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should initialize with UnifiedEmbeddingService', () => {
-      expect(service).toBeInstanceOf(MemoryEmbeddingService);
-      expect(UnifiedEmbeddingService).toHaveBeenCalled();
-    });
-  });
-
-  describe('createAndStoreEmbedding', () => {
-    it('should create and store embedding successfully', async () => {
-      const mockEmbeddingResult = {
-        embedding: new Array(768).fill(0.1),
-        model: 'test-model',
-        usage: {
-          prompt_tokens: 10,
-          total_tokens: 10
-        }
-      };
-
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(mockEmbeddingResult);
-      vi.mocked(DatabaseUtils.run).mockResolvedValue(undefined);
-
-      const result = await service.createAndStoreEmbedding(
-        mockDb,
-        'memory-123',
-        'Test content',
-        'episodic' as MemoryType
-      );
-
-      expect(result).toEqual(mockEmbeddingResult);
-      expect(mockEmbeddingService.generateEmbedding).toHaveBeenCalledWith('Test content');
-      expect(DatabaseUtils.run).toHaveBeenCalledWith(
-        mockDb,
-        expect.stringContaining('INSERT OR REPLACE INTO memory_embedding'),
-        ['memory-123', JSON.stringify(mockEmbeddingResult.embedding), 768, 'test-model']
-      );
-    });
-
-    it('should return null when embedding service is not available', async () => {
-      mockEmbeddingService.isAvailable.mockReturnValue(false);
-
-      const result = await service.createAndStoreEmbedding(
-        mockDb,
-        'memory-123',
-        'Test content',
-        'episodic' as MemoryType
-      );
-
-      expect(result).toBeNull();
-      expect(mockEmbeddingService.generateEmbedding).not.toHaveBeenCalled();
-    });
-
-    it('should return null when embedding generation fails', async () => {
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(null);
-
-      const result = await service.createAndStoreEmbedding(
-        mockDb,
-        'memory-123',
-        'Test content',
-        'episodic' as MemoryType
-      );
-
-      expect(result).toBeNull();
-      expect(DatabaseUtils.run).not.toHaveBeenCalled();
-    });
-
-    it('should handle database errors gracefully', async () => {
-      const mockEmbeddingResult = {
-        embedding: new Array(768).fill(0.1),
-        model: 'test-model',
-        usage: { prompt_tokens: 10, total_tokens: 10 }
-      };
-
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(mockEmbeddingResult);
-      vi.mocked(DatabaseUtils.run).mockRejectedValue(new Error('Database error'));
-
-      const result = await service.createAndStoreEmbedding(
-        mockDb,
-        'memory-123',
-        'Test content',
-        'episodic' as MemoryType
-      );
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('searchBySimilarity', () => {
-    it('should search by similarity successfully', async () => {
-      const mockEmbeddingResult = {
-        embedding: new Array(768).fill(0.1),
-        model: 'test-model',
-        usage: { prompt_tokens: 10, total_tokens: 10 }
-      };
-
-      const mockEmbeddings = [
-        { id: 'memory-1', content: 'Test content 1', embedding: new Array(768).fill(0.1) },
-        { id: 'memory-2', content: 'Test content 2', embedding: new Array(768).fill(0.2) }
-      ];
-
-      const mockSimilarities = [
-        { id: 'memory-1', content: 'Test content 1', similarity: 0.9, score: 0.9 },
-        { id: 'memory-2', content: 'Test content 2', similarity: 0.8, score: 0.8 }
-      ];
-
-      const mockMemory = {
-        id: 'memory-1',
-        content: 'Test content 1',
-        type: 'episodic',
-        importance: 0.8,
-        created_at: '2023-01-01T00:00:00Z',
-        last_accessed: '2023-01-02T00:00:00Z',
-        pinned: false,
-        tags: '["tag1", "tag2"]'
-      };
-
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(mockEmbeddingResult);
-      mockEmbeddingService.searchSimilar.mockResolvedValue(mockSimilarities);
-      vi.mocked(DatabaseUtils.all)
-        .mockResolvedValueOnce(mockEmbeddings) // getAllEmbeddings
-        .mockResolvedValueOnce([mockMemory]); // getMemoryById
-
-      const results = await service.searchBySimilarity(mockDb, 'test query');
-
-      expect(results).toHaveLength(1);
-      expect(results[0]).toEqual({
-        id: 'memory-1',
-        content: 'Test content 1',
-        type: 'episodic',
-        importance: 0.8,
-        created_at: '2023-01-01T00:00:00Z',
-        last_accessed: '2023-01-02T00:00:00Z',
-        pinned: false,
-        tags: ['tag1', 'tag2'],
-        similarity: 0.9,
-        score: 0.9
-      });
-    });
-
-    it('should return empty array when embedding service is not available', async () => {
-      mockEmbeddingService.isAvailable.mockReturnValue(false);
-
-      const results = await service.searchBySimilarity(mockDb, 'test query');
-
-      expect(results).toEqual([]);
-    });
-
-    it('should return empty array when query embedding fails', async () => {
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(null);
-
-      const results = await service.searchBySimilarity(mockDb, 'test query');
-
-      expect(results).toEqual([]);
-    });
-
-    it('should return empty array when no embeddings found', async () => {
-      const mockEmbeddingResult = {
-        embedding: new Array(768).fill(0.1),
-        model: 'test-model',
-        usage: { prompt_tokens: 10, total_tokens: 10 }
-      };
-
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(mockEmbeddingResult);
-      vi.mocked(DatabaseUtils.all).mockResolvedValue([]); // No embeddings
-
-      const results = await service.searchBySimilarity(mockDb, 'test query');
-
-      expect(results).toEqual([]);
-    });
-
-    it('should apply type filters', async () => {
-      const mockEmbeddingResult = {
-        embedding: new Array(768).fill(0.1),
-        model: 'test-model',
-        usage: { prompt_tokens: 10, total_tokens: 10 }
-      };
-
-      const mockEmbeddings = [
-        { id: 'memory-1', content: 'Test content 1', embedding: new Array(768).fill(0.1) }
-      ];
-
-      const mockSimilarities = [
-        { id: 'memory-1', content: 'Test content 1', similarity: 0.9, score: 0.9 }
-      ];
-
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(mockEmbeddingResult);
-      mockEmbeddingService.searchSimilar.mockResolvedValue(mockSimilarities);
-      vi.mocked(DatabaseUtils.all).mockResolvedValue(mockEmbeddings);
-
-      await service.searchBySimilarity(mockDb, 'test query', {
-        type: ['episodic', 'semantic'],
-        limit: 5,
-        threshold: 0.8
-      });
-
-      expect(DatabaseUtils.all).toHaveBeenCalledWith(
-        mockDb,
-        expect.stringContaining('WHERE mi.type IN (?,?)'),
-        ['episodic', 'semantic']
-      );
-    });
-
-    it('should handle memory not found gracefully', async () => {
-      const mockEmbeddingResult = {
-        embedding: new Array(768).fill(0.1),
-        model: 'test-model',
-        usage: { prompt_tokens: 10, total_tokens: 10 }
-      };
-
-      const mockEmbeddings = [
-        { id: 'memory-1', content: 'Test content 1', embedding: new Array(768).fill(0.1) }
-      ];
-
-      const mockSimilarities = [
-        { id: 'memory-1', content: 'Test content 1', similarity: 0.9, score: 0.9 }
-      ];
-
-      mockEmbeddingService.generateEmbedding.mockResolvedValue(mockEmbeddingResult);
-      mockEmbeddingService.searchSimilar.mockResolvedValue(mockSimilarities);
-      vi.mocked(DatabaseUtils.all)
-        .mockResolvedValueOnce(mockEmbeddings) // getAllEmbeddings
-        .mockResolvedValueOnce([]); // getMemoryById - no memory found
-
-      const results = await service.searchBySimilarity(mockDb, 'test query');
-
-      expect(results).toEqual([]);
-    });
-  });
-
-  describe('deleteEmbedding', () => {
-    it('should delete embedding successfully', async () => {
-      vi.mocked(DatabaseUtils.run).mockResolvedValue(undefined);
-
-      await service.deleteEmbedding(mockDb, 'memory-123');
-
-      expect(DatabaseUtils.run).toHaveBeenCalledWith(
-        mockDb,
-        'DELETE FROM memory_embedding WHERE memory_id = ?',
-        ['memory-123']
-      );
-    });
-
-    it('should handle database errors gracefully', async () => {
-      vi.mocked(DatabaseUtils.run).mockRejectedValue(new Error('Database error'));
-
-      // Should not throw
-      await expect(service.deleteEmbedding(mockDb, 'memory-123')).resolves.toBeUndefined();
-    });
-  });
-
-  describe('isAvailable', () => {
-    it('should return embedding service availability', () => {
-      mockEmbeddingService.isAvailable.mockReturnValue(true);
-      expect(service.isAvailable()).toBe(true);
-
-      mockEmbeddingService.isAvailable.mockReturnValue(false);
-      expect(service.isAvailable()).toBe(false);
-    });
-  });
-
-  describe('getEmbeddingStats', () => {
-    it('should return embedding statistics', async () => {
-      const mockStats = {
-        total_embeddings: 100,
-        avg_dimensions: 768
-      };
-
-      vi.mocked(DatabaseUtils.all).mockResolvedValue([mockStats]);
-
-      const stats = await service.getEmbeddingStats(mockDb);
-
-      expect(stats).toEqual({
-        totalEmbeddings: 100,
-        averageDimensions: 768,
-        model: 'test-model'
-      });
-    });
-
-    it('should handle database errors gracefully', async () => {
-      vi.mocked(DatabaseUtils.all).mockRejectedValue(new Error('Database error'));
-
-      const stats = await service.getEmbeddingStats(mockDb);
-
-      expect(stats).toEqual({
-        totalEmbeddings: 0,
-        averageDimensions: 0,
-        model: 'unknown'
-      });
-    });
-
-    it('should handle empty results', async () => {
-      vi.mocked(DatabaseUtils.all).mockResolvedValue([]);
-
-      const stats = await service.getEmbeddingStats(mockDb);
-
-      expect(stats).toEqual({
-        totalEmbeddings: 0,
-        averageDimensions: 0,
-        model: 'test-model'
-      });
-    });
-  });
-
-  describe('private methods', () => {
-    describe('getAllEmbeddings', () => {
-      it('should get all embeddings without type filter', async () => {
-        const mockEmbeddings = [
-          { memory_id: 'memory-1', content: 'Content 1', embedding: '[0.1,0.2,0.3]' },
-          { memory_id: 'memory-2', content: 'Content 2', embedding: '[0.4,0.5,0.6]' }
-        ];
-
-        vi.mocked(DatabaseUtils.all).mockResolvedValue(mockEmbeddings);
-
-        const result = await (service as any).getAllEmbeddings(mockDb);
-
-        expect(result).toEqual([
-          { id: 'memory-1', content: 'Content 1', embedding: [0.1, 0.2, 0.3] },
-          { id: 'memory-2', content: 'Content 2', embedding: [0.4, 0.5, 0.6] }
-        ]);
-      });
-
-      it('should get embeddings with type filter', async () => {
-        const mockEmbeddings = [
-          { memory_id: 'memory-1', content: 'Content 1', embedding: '[0.1,0.2,0.3]' }
-        ];
-
-        vi.mocked(DatabaseUtils.all).mockResolvedValue(mockEmbeddings);
-
-        const result = await (service as any).getAllEmbeddings(mockDb, ['episodic', 'semantic']);
-
-        expect(DatabaseUtils.all).toHaveBeenCalledWith(
-          mockDb,
-          expect.stringContaining('WHERE mi.type IN (?,?)'),
-          ['episodic', 'semantic']
-        );
-        expect(result).toHaveLength(1);
-      });
-    });
-
-    describe('getMemoryById', () => {
-      it('should get memory by id', async () => {
-        const mockMemory = {
-          id: 'memory-1',
-          content: 'Test content',
-          type: 'episodic',
-          importance: 0.8,
-          created_at: '2023-01-01T00:00:00Z',
-          last_accessed: '2023-01-02T00:00:00Z',
-          pinned: false,
-          tags: '["tag1", "tag2"]'
-        };
-
-        vi.mocked(DatabaseUtils.all).mockResolvedValue([mockMemory]);
-
-        const result = await (service as any).getMemoryById(mockDb, 'memory-1');
-
-        expect(result).toEqual(mockMemory);
-        expect(DatabaseUtils.all).toHaveBeenCalledWith(
-          mockDb,
-          expect.stringContaining('SELECT id, content, type, importance'),
-          ['memory-1']
-        );
-      });
-
-      it('should return null when memory not found', async () => {
-        vi.mocked(DatabaseUtils.all).mockResolvedValue([]);
-
-        const result = await (service as any).getMemoryById(mockDb, 'memory-1');
-
-        expect(result).toBeNull();
-      });
-    });
-  });
-});

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

@@ -1,289 +0,0 @@
-/**
- * 메모리 임베딩 저장 및 검색 서비스
- * 데이터베이스와 임베딩 서비스를 연동
- */
-
-import { UnifiedEmbeddingService } from './unified-embedding-service.js';
-import type { EmbeddingResult } from '../types/embedding.types.js';
-import { DatabaseUtils } from '../utils/database.js';
-import type { MemoryType } from '../types/index.js';
-
-export interface MemoryEmbedding {
-  memory_id: string;
-  embedding: number[];
-  created_at: string;
-}
-
-export interface VectorSearchResult {
-  id: string;
-  content: string;
-  type: string;
-  importance: number;
-  created_at: string;
-  last_accessed?: string;
-  pinned: boolean;
-  tags?: string[];
-  similarity: number;
-  score: number;
-}
-
-export class MemoryEmbeddingService {
-  private embeddingService: UnifiedEmbeddingService;
-
-  constructor() {
-    this.embeddingService = new UnifiedEmbeddingService();
-  }
-
-  /**
-   * sqlite-vec 확장 로드
-   */
-  private loadVecExtension(db: any): void {
-    try {
-      db.loadExtension('/usr/lib/vec0');
-    } catch (error) {
-      console.warn('⚠️ sqlite-vec 확장 로드 실패:', error);
-    }
-  }
-
-  /**
-   * 메모리에 임베딩 생성 및 저장
-   */
-  async createAndStoreEmbedding(
-    db: any,
-    memoryId: string,
-    content: string,
-    type: MemoryType
-  ): Promise<EmbeddingResult | null> {
-    if (!this.embeddingService.isAvailable()) {
-      console.warn('⚠️ 임베딩 서비스가 사용 불가능합니다. 임베딩을 건너뜁니다.');
-      return null;
-    }
-
-    try {
-      // sqlite-vec 확장 로드
-      this.loadVecExtension(db);
-      
-      // 임베딩 생성
-      const embeddingResult = await this.embeddingService.generateEmbedding(content);
-      if (!embeddingResult) {
-        return null;
-      }
-
-      // 제공자별 테이블명 결정
-      const tableName = this.getVectorTableName(embeddingResult.provider || 'tfidf');
-      
-      // memory_embedding 테이블에 저장
-      await DatabaseUtils.run(db, `
-        INSERT OR REPLACE INTO memory_embedding (memory_id, embedding, dim, model, embedding_provider, dimensions, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
-      `, [
-        memoryId,
-        JSON.stringify(embeddingResult.embedding),
-        embeddingResult.embedding.length,
-        embeddingResult.model,
-        embeddingResult.provider,
-        embeddingResult.embedding.length,
-      ]);
-
-      // vec0 테이블에 저장
-      await DatabaseUtils.run(db, `
-        INSERT OR REPLACE INTO ${tableName} (rowid, embedding)
-        VALUES ((SELECT rowid FROM memory_embedding WHERE memory_id = ?), ?)
-      `, [
-        memoryId,
-        JSON.stringify(embeddingResult.embedding)
-      ]);
-
-      console.log(`✅ 임베딩 저장 완료: ${memoryId} (${embeddingResult.embedding.length}차원, ${embeddingResult.provider})`);
-      return embeddingResult;
-
-    } catch (error) {
-      console.error(`❌ 임베딩 저장 실패 (${memoryId}):`, error);
-      return null;
-    }
-  }
-
-  /**
-   * 제공자별 vec0 테이블명 반환
-   */
-  private getVectorTableName(provider: string): string {
-    switch (provider) {
-      case 'tfidf':
-        return 'memory_item_vec_tfidf';
-      case 'minilm':
-        return 'memory_item_vec_minilm';
-      case 'openai':
-        return 'memory_item_vec_openai';
-      case 'gemini':
-        return 'memory_item_vec_gemini';
-      default:
-        return 'memory_item_vec_tfidf'; // 기본값
-    }
-  }
-
-  /**
-   * 벡터 유사도 검색
-   */
-  async searchBySimilarity(
-    db: any,
-    query: string,
-    filters?: {
-      type?: MemoryType[];
-      limit?: number;
-      threshold?: number;
-    }
-  ): Promise<VectorSearchResult[]> {
-    if (!this.embeddingService.isAvailable()) {
-      console.warn('⚠️ 임베딩 서비스가 사용 불가능합니다.');
-      return [];
-    }
-
-    try {
-      // 쿼리 임베딩 생성
-      const queryEmbedding = await this.embeddingService.generateEmbedding(query);
-      if (!queryEmbedding) {
-        return [];
-      }
-
-      // 제공자별 테이블에서 검색
-      const tableName = this.getVectorTableName(queryEmbedding.provider || 'tfidf');
-      
-      // vec0 테이블에서 유사도 검색
-      const similarities = await DatabaseUtils.all(db, `
-        SELECT 
-          m.id,
-          m.content,
-          m.type,
-          m.importance,
-          m.created_at,
-          m.last_accessed,
-          m.pinned,
-          m.tags,
-          v.distance as similarity,
-          (1 - v.distance) as score
-        FROM memory_item m
-        JOIN memory_embedding me ON m.id = me.memory_id
-        JOIN ${tableName} v ON me.rowid = v.rowid
-        WHERE me.embedding_provider = ?
-        ${filters?.type ? `AND m.type IN (${filters.type.map(() => '?').join(',')})` : ''}
-        ORDER BY v.distance ASC
-        LIMIT ?
-      `, [
-        queryEmbedding.provider,
-        ...(filters?.type || []),
-        filters?.limit || 10
-      ]);
-
-      // 결과를 VectorSearchResult 형태로 변환
-      const results: VectorSearchResult[] = similarities.map((row: any) => ({
-        id: row.id,
-        content: row.content,
-        type: row.type,
-        importance: row.importance,
-        created_at: row.created_at,
-        last_accessed: row.last_accessed,
-        pinned: row.pinned,
-        tags: row.tags ? JSON.parse(row.tags) : [],
-        similarity: row.similarity,
-        score: row.score,
-      }));
-
-      return results;
-
-    } catch (error) {
-      console.error('❌ 벡터 검색 실패:', error);
-      return [];
-    }
-  }
-
-
-  /**
-   * 임베딩 삭제
-   */
-  async deleteEmbedding(db: any, memoryId: string): Promise<void> {
-    try {
-      // 제공자 정보 가져오기
-      const embeddingInfo = await DatabaseUtils.get(db, `
-        SELECT embedding_provider FROM memory_embedding WHERE memory_id = ?
-      `, [memoryId]);
-
-      if (embeddingInfo) {
-        // 해당 제공자의 vec0 테이블에서 삭제
-        const tableName = this.getVectorTableName(embeddingInfo.embedding_provider);
-        await DatabaseUtils.run(db, `
-          DELETE FROM ${tableName} 
-          WHERE rowid = (SELECT rowid FROM memory_embedding WHERE memory_id = ?)
-        `, [memoryId]);
-      }
-
-      // memory_embedding 테이블에서 삭제
-      await DatabaseUtils.run(db, 'DELETE FROM memory_embedding WHERE memory_id = ?', [memoryId]);
-      console.log(`✅ 임베딩 삭제 완료: ${memoryId}`);
-    } catch (error) {
-      console.error(`❌ 임베딩 삭제 실패 (${memoryId}):`, error);
-    }
-  }
-
-  /**
-   * 임베딩 서비스 사용 가능 여부 확인
-   */
-  isAvailable(): boolean {
-    return this.embeddingService.isAvailable();
-  }
-
-  /**
-   * 임베딩 통계 정보
-   */
-  async getEmbeddingStats(db: any): Promise<{
-    totalEmbeddings: number;
-    averageDimensions: number;
-    model: string;
-    providerStats: Array<{
-      provider: string;
-      count: number;
-      dimensions: number;
-    }>;
-  }> {
-    try {
-      // 전체 통계
-      const stats = await DatabaseUtils.all(db, `
-        SELECT 
-          COUNT(*) as total_embeddings,
-          AVG(dimensions) as avg_dimensions
-        FROM memory_embedding
-      `);
-
-      // 제공자별 통계
-      const providerStats = await DatabaseUtils.all(db, `
-        SELECT 
-          embedding_provider as provider,
-          COUNT(*) as count,
-          AVG(dimensions) as dimensions
-        FROM memory_embedding
-        GROUP BY embedding_provider
-        ORDER BY count DESC
-      `);
-
-      const stat = stats[0];
-      
-      return {
-        totalEmbeddings: stat.total_embeddings || 0,
-        averageDimensions: stat.avg_dimensions || 0,
-        model: this.embeddingService.getModelInfo().model,
-        providerStats: providerStats.map((row: any) => ({
-          provider: row.provider,
-          count: row.count,
-          dimensions: Math.round(row.dimensions),
-        })),
-      };
-    } catch (error) {
-      console.error('❌ 임베딩 통계 조회 실패:', error);
-      return {
-        totalEmbeddings: 0,
-        averageDimensions: 0,
-        model: 'unknown',
-        providerStats: [],
-      };
-    }
-  }
-}