memento-mcp-server 0.1.0

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

@@ -0,0 +1,417 @@
+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

@@ -0,0 +1,289 @@
+/**
+ * 메모리 임베딩 저장 및 검색 서비스
+ * 데이터베이스와 임베딩 서비스를 연동
+ */
+
+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: [],
+      };
+    }
+  }
+}