memento-mcp-server 0.1.0

package/src/algorithms/search-engine.ts

@@ -0,0 +1,392 @@
+/**
+ * 개선된 검색 엔진 구현
+ * FTS5 + 랭킹 알고리즘 + 필터링 결합
+ */
+
+import { SearchRanking } from './search-ranking.js';
+import type { MemorySearchResult, MemorySearchFilters } from '../types/index.js';
+import { getStopWords } from '../utils/stopwords.js';
+
+export interface SearchQuery {
+  query: string;
+  filters?: MemorySearchFilters | undefined;
+  limit?: number | undefined;
+}
+
+export interface SearchResult {
+  id: string;
+  content: string;
+  type: string;
+  importance: number;
+  created_at: string;
+  last_accessed?: string;
+  pinned: boolean;
+  tags?: string[];
+  score: number;
+  recall_reason: string;
+}
+
+export class SearchEngine {
+  private ranking: SearchRanking;
+
+  constructor() {
+    this.ranking = new SearchRanking();
+  }
+
+  /**
+   * 개선된 검색 구현 - FTS5 최적화
+   */
+  async search(
+    db: any,
+    query: SearchQuery
+  ): Promise<{ items: SearchResult[], total_count: number, query_time: number }> {
+    const startTime = process.hrtime.bigint();
+    const { query: searchQuery, filters, limit = 10 } = query;
+    
+    // 1. ID 필터가 있으면 내용 검색 조건을 건너뛰기
+    const hasIdFilter = filters?.id && filters.id.length > 0;
+    
+    let sql: string;
+    const params: any[] = [];
+    
+    // 2. FTS5 검색 사용 (ID 필터가 없고 검색어가 있을 때)
+    if (!hasIdFilter && searchQuery.trim().length > 0) {
+      // FTS5 사용 가능 여부 확인
+      const ftsAvailable = await this.checkFTS5Availability(db);
+      
+      if (ftsAvailable) {
+        const ftsQuery = this.buildFTSQuery(searchQuery);
+        sql = `
+          SELECT 
+            m.id, m.content, m.type, m.importance, m.created_at, 
+            m.last_accessed, m.pinned, m.tags, m.source,
+            memory_item_fts.rank as fts_rank
+          FROM memory_item_fts
+          JOIN memory_item m ON memory_item_fts.rowid = m.rowid
+          WHERE memory_item_fts MATCH ?
+        `;
+        params.push(ftsQuery);
+      } else {
+        // FTS5가 없으면 기본 LIKE 검색 사용
+        const likeQuery = `%${searchQuery}%`;
+        sql = `
+          SELECT 
+            m.id, m.content, m.type, m.importance, m.created_at, 
+            m.last_accessed, m.pinned, m.tags, m.source,
+            0 as fts_rank
+          FROM memory_item m
+          WHERE m.content LIKE ? OR m.tags LIKE ? OR m.source LIKE ?
+        `;
+        params.push(likeQuery, likeQuery, likeQuery);
+      }
+    } else {
+      // 3. 기본 SQL 쿼리 구성 (ID 필터가 있거나 검색어가 없을 때)
+      sql = `
+        SELECT 
+          m.id, m.content, m.type, m.importance, m.created_at, 
+          m.last_accessed, m.pinned, m.tags, m.source,
+          0 as fts_rank
+        FROM memory_item m
+      `;
+      
+      // 내용 검색 조건 (검색어가 있을 때만)
+      if (!hasIdFilter && searchQuery.trim().length > 0) {
+        const likeQuery = `%${searchQuery}%`;
+        sql += ` WHERE m.content LIKE ?`;
+        params.push(likeQuery);
+      }
+    }
+    
+    // 4. 필터 조건 추가
+    const conditions: string[] = [];
+    
+    if (filters?.id && filters.id.length > 0) {
+      conditions.push(`m.id IN (${filters.id.map(() => '?').join(',')})`);
+      params.push(...filters.id);
+    }
+    
+    if (filters?.type && filters.type.length > 0) {
+      conditions.push(`m.type IN (${filters.type.map(() => '?').join(',')})`);
+      params.push(...filters.type);
+    }
+    
+    if (filters?.privacy_scope && filters.privacy_scope.length > 0) {
+      conditions.push(`m.privacy_scope IN (${filters.privacy_scope.map(() => '?').join(',')})`);
+      params.push(...filters.privacy_scope);
+    }
+    
+    if (filters?.pinned !== undefined) {
+      conditions.push(`m.pinned = ?`);
+      params.push(filters.pinned ? 1 : 0); // boolean을 숫자로 변환
+    }
+    
+    if (filters?.time_from) {
+      conditions.push(`m.created_at >= ?`);
+      params.push(filters.time_from);
+    }
+    
+    if (filters?.time_to) {
+      conditions.push(`m.created_at <= ?`);
+      params.push(filters.time_to);
+    }
+    
+    // WHERE 절 추가
+    if (conditions.length > 0) {
+      const whereClause = sql.includes('WHERE') ? ' AND ' : ' WHERE ';
+      sql += whereClause + conditions.join(' AND ');
+    }
+    
+    // 5. 결과 제한 및 정렬 최적화
+    sql += ` ORDER BY fts_rank DESC, m.created_at DESC LIMIT ?`;
+    params.push(limit * 3); // FTS5 랭킹을 고려하여 더 많은 후보 가져오기
+    
+    // 6. 데이터베이스 쿼리 실행
+    console.log('🔍 검색 쿼리:', sql);
+    console.log('🔍 검색 파라미터:', params);
+    const results = await this.executeQuery(db, sql, params);
+    console.log('🔍 검색 결과 개수:', results.length);
+    
+    // 7. 랭킹 알고리즘 적용 (FTS5 랭킹 활용)
+    const rankedResults = this.applyRanking(results, searchQuery);
+    
+    // 8. 최종 결과 반환 (limit 적용)
+    const finalResults = rankedResults.slice(0, limit);
+    
+    // 9. 쿼리 시간 측정
+    const endTime = process.hrtime.bigint();
+    const queryTime = Number(endTime - startTime) / 1_000_000; // 밀리초로 변환
+    
+    return {
+      items: finalResults,
+      total_count: finalResults.length,
+      query_time: queryTime
+    };
+  }
+
+  /**
+   * FTS5 검색 쿼리 구성
+   * 아키텍처 문서에 따른 쿼리 전처리 구현
+   */
+  private buildFTSQuery(query: string): string {
+    console.log('🔍 원본 쿼리:', `"${query}"`);
+    
+    // 1. 쿼리 전처리
+    const preprocessedQuery = this.preprocessQuery(query);
+    console.log('🔍 전처리 후:', `"${preprocessedQuery}"`);
+    
+    if (preprocessedQuery.length === 0) {
+      console.log('🔍 빈 쿼리, 모든 문서 검색');
+      return '*'; // 빈 쿼리인 경우 모든 문서 검색
+    }
+    
+    // 2. FTS5 안전 쿼리 생성
+    const safeQuery = this.makeFTSSafe(preprocessedQuery);
+    console.log('🔍 FTS5 안전 쿼리:', `"${safeQuery}"`);
+    
+    if (safeQuery.length === 0) {
+      console.log('🔍 안전 쿼리 빈 문자열, 모든 문서 검색');
+      return '*';
+    }
+    
+    return safeQuery;
+  }
+
+  /**
+   * 쿼리 전처리 - 아키텍처 문서의 전처리 과정 구현
+   */
+  private preprocessQuery(query: string): string {
+    // 1. 공백 정규화
+    let processed = query.trim().replace(/\s+/g, ' ');
+    
+    // 2. 한글과 영문, 숫자, 공백만 유지 (특수문자 제거)
+    processed = processed.replace(/[^a-zA-Z0-9가-힣\s]/g, ' ');
+    
+    // 3. 연속된 공백 제거
+    processed = processed.replace(/\s+/g, ' ');
+    
+    // 4. 불용어 제거 (한국어/영어 불용어)
+    const stopWords = getStopWords();
+    const words = processed.split(' ').filter(word => 
+      word.length > 0 && !stopWords.has(word.toLowerCase())
+    );
+    
+    // 5. FTS5를 위한 공백으로 구분된 쿼리 반환
+    return words.join(' ');
+  }
+
+  /**
+   * FTS5 안전 쿼리 생성
+   */
+  private makeFTSSafe(query: string): string {
+    // FTS5에서 특수문자 이스케이프
+    return query
+      .replace(/"/g, '""')  // 따옴표 이스케이프
+      .replace(/'/g, "''")  // 작은따옴표 이스케이프
+      .replace(/[\[\]{}()]/g, ' ') // 대괄호, 중괄호, 소괄호 제거
+      .replace(/\s+/g, ' ') // 연속 공백 정리
+      .trim();
+  }
+
+  /**
+   * 데이터베이스 쿼리 실행
+   */
+  private async executeQuery(db: any, sql: string, params: any[]): Promise<any[]> {
+    // better-sqlite3는 동기적이므로 직접 실행
+    try {
+      return db.prepare(sql).all(params);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  /**
+   * 랭킹 알고리즘 적용 - FTS5 랭킹 활용
+   */
+  private applyRanking(results: any[], query: string): SearchResult[] {
+    const selectedContents: string[] = [];
+    
+    return results
+      .map((row: any) => {
+        // FTS5 랭킹이 있으면 활용, 없으면 기본 관련성 계산
+        const ftsRank = row.fts_rank || 0;
+        const relevance = ftsRank > 0 ? 
+          Math.min(ftsRank / 100, 1.0) : // FTS5 랭킹을 0-1 범위로 정규화
+          this.ranking.calculateRelevance({
+            query,
+            content: row.content,
+            tags: row.tags ? JSON.parse(row.tags) : []
+          });
+        
+        // 최근성 계산
+        const recency = this.ranking.calculateRecency(
+          new Date(row.created_at),
+          row.type
+        );
+        
+        // 중요도 계산
+        const importance = this.ranking.calculateImportance(
+          row.importance,
+          row.pinned,
+          row.type
+        );
+        
+        // 사용성 계산 (기본 메트릭 사용)
+        const usage = this.ranking.calculateUsage({
+          viewCount: 1, // 기본값
+          citeCount: 0,
+          editCount: 0
+        });
+        
+        // 중복 패널티 계산
+        const duplicationPenalty = this.ranking.calculateDuplicationPenalty(
+          row.content,
+          selectedContents
+        );
+        
+        // 최종 점수 계산 (FTS5 랭킹 가중치 적용)
+        const finalScore = ftsRank > 0 ? 
+          ftsRank * 0.7 + this.ranking.calculateFinalScore({
+            relevance: 0.3,
+            recency,
+            importance,
+            usage,
+            duplication_penalty: duplicationPenalty
+          }) * 0.3 :
+          this.ranking.calculateFinalScore({
+            relevance,
+            recency,
+            importance,
+            usage,
+            duplication_penalty: duplicationPenalty
+          });
+        
+        // 선택된 콘텐츠에 추가 (다양성 확보)
+        selectedContents.push(row.content);
+        
+        return {
+          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) : [],
+          score: finalScore,
+          recall_reason: this.generateRecallReason(relevance, recency, importance, finalScore, ftsRank > 0)
+        };
+      })
+      .sort((a, b) => b.score - a.score); // 점수 내림차순 정렬
+  }
+
+  /**
+   * FTS5 사용 가능 여부 확인
+   */
+  private async checkFTS5Availability(db: any): Promise<boolean> {
+    try {
+      // FTS5 테이블 존재 여부 확인
+      const result = db.prepare(`
+        SELECT name FROM sqlite_master 
+        WHERE type='table' AND name='memory_item_fts'
+      `).get();
+      
+      if (!result) {
+        console.log('⚠️  FTS5 테이블이 존재하지 않음, 기본 검색으로 전환');
+        return false;
+      }
+      
+      // FTS5 테이블에 데이터가 있는지 확인
+      const count = db.prepare('SELECT COUNT(*) as count FROM memory_item_fts').get();
+      const hasData = count && count.count > 0;
+      
+      if (!hasData) {
+        console.log('⚠️  FTS5 테이블에 데이터가 없음, 기본 검색으로 전환');
+        return false;
+      }
+      
+      // FTS5 쿼리 테스트
+      try {
+        db.prepare('SELECT * FROM memory_item_fts LIMIT 1').get();
+        console.log('✅ FTS5 사용 가능');
+        return true;
+      } catch (ftsError) {
+        console.log('⚠️  FTS5 쿼리 실패, 기본 검색으로 전환:', ftsError);
+        return false;
+      }
+    } catch (error) {
+      console.log('⚠️  FTS5 사용 불가능, 기본 검색으로 전환:', error);
+      return false;
+    }
+  }
+
+  /**
+   * 검색 이유 생성
+   */
+  private generateRecallReason(
+    relevance: number,
+    recency: number,
+    importance: number,
+    finalScore: number,
+    isFTS: boolean = false
+  ): string {
+    const reasons: string[] = [];
+    
+    if (isFTS) {
+      reasons.push('FTS5 전문 검색');
+    }
+    if (relevance > 0.7) {
+      reasons.push('높은 관련성');
+    }
+    if (recency > 0.8) {
+      reasons.push('최근 생성');
+    }
+    if (importance > 0.8) {
+      reasons.push('높은 중요도');
+    }
+    if (finalScore > 0.9) {
+      reasons.push('종합 점수 우수');
+    }
+    
+    return reasons.length > 0 ? reasons.join(', ') : '일반 검색 결과';
+  }
+}

package/src/algorithms/search-ranking.spec.ts

@@ -0,0 +1,293 @@
+import { describe, it, expect } from 'vitest';
+import { SearchRanking } from './search-ranking.js';
+
+describe('SearchRanking', () => {
+  const ranking = new SearchRanking();
+
+  describe('calculateFinalScore', () => {
+    it('가중치에 따라 최종 점수를 계산한다', () => {
+      const score = ranking.calculateFinalScore({
+        relevance: 0.9,
+        recency: 0.8,
+        importance: 0.6,
+        usage: 0.4,
+        duplication_penalty: 0.2,
+      });
+
+      const expected = 0.5 * 0.9 + 0.2 * 0.8 + 0.2 * 0.6 + 0.1 * 0.4 - 0.15 * 0.2;
+      expect(score).toBeCloseTo(expected, 5);
+    });
+
+    it('음수 점수가 나올 수 있다', () => {
+      const score = ranking.calculateFinalScore({
+        relevance: 0.1,
+        recency: 0.1,
+        importance: 0.1,
+        usage: 0.1,
+        duplication_penalty: 0.9,
+      });
+
+      expect(score).toBeLessThan(0);
+    });
+  });
+
+  describe('calculateRelevance', () => {
+    it('기본 관련성 점수를 계산한다', () => {
+      const relevance = ranking.calculateRelevance({
+        query: 'React Hook',
+        content: 'React Hook에 대해 설명한 문서입니다. Hook API 예시 포함.',
+        tags: ['frontend', 'react']
+      });
+
+      expect(relevance).toBeLessThanOrEqual(1);
+      expect(relevance).toBeGreaterThan(0);
+    });
+
+    it('임베딩 유사도가 제공된 경우 관련성 점수를 계산한다', () => {
+      const relevance = ranking.calculateRelevance({
+        query: 'React Hook',
+        content: 'React Hook에 대한 내용',
+        tags: ['react'],
+        embeddingSimilarity: {
+          queryEmbedding: [0.1, 0.2, 0.3, 0.4],
+          docEmbedding: [0.1, 0.2, 0.3, 0.4]
+        }
+      });
+      expect(relevance).toBeGreaterThan(0);
+    });
+
+    it('BM25 결과가 제공된 경우 관련성 점수를 계산한다', () => {
+      const relevance = ranking.calculateRelevance({
+        query: 'React Hook',
+        content: 'React Hook에 대한 내용',
+        tags: ['react'],
+        bm25Result: { score: 2.5, normalizedScore: 0.8 }
+      });
+      expect(relevance).toBeGreaterThan(0);
+    });
+
+    it('타이틀이 있는 경우 타이틀 히트 점수를 반영한다', () => {
+      const relevance = ranking.calculateRelevance({
+        query: 'React Hook',
+        content: 'React Hook에 대한 내용',
+        title: 'React Hook Guide',
+        tags: ['react']
+      });
+      expect(relevance).toBeGreaterThan(0);
+    });
+
+    it('빈 문자열 입력에 대해 안전하게 처리한다', () => {
+      const relevance = ranking.calculateRelevance({
+        query: '',
+        content: '',
+        tags: []
+      });
+      expect(relevance).toBe(0);
+    });
+
+    it('null/undefined 입력에 대해 안전하게 처리한다', () => {
+      const relevance = ranking.calculateRelevance({
+        query: null as any,
+        content: undefined as any,
+        tags: []
+      });
+      expect(relevance).toBe(0);
+    });
+  });
+
+  describe('calculateRecency', () => {
+    it('최근성이 높은 기억은 더 높은 점수를 받는다', () => {
+      const recent = ranking.calculateRecency(
+        new Date(Date.now() - 1 * 24 * 60 * 60 * 1000),
+        'semantic'
+      );
+      const old = ranking.calculateRecency(
+        new Date(Date.now() - 200 * 24 * 60 * 60 * 1000),
+        'semantic'
+      );
+
+      expect(recent).toBeGreaterThan(old);
+      expect(recent).toBeLessThanOrEqual(1);
+    });
+
+    it('타입별로 다른 반감기를 적용한다', () => {
+      const working = ranking.calculateRecency(
+        new Date(Date.now() - 1 * 24 * 60 * 60 * 1000),
+        'working'
+      );
+      const episodic = ranking.calculateRecency(
+        new Date(Date.now() - 1 * 24 * 60 * 60 * 1000),
+        'episodic'
+      );
+      const semantic = ranking.calculateRecency(
+        new Date(Date.now() - 1 * 24 * 60 * 60 * 1000),
+        'semantic'
+      );
+
+      expect(working).toBeLessThan(episodic);
+      expect(episodic).toBeLessThan(semantic);
+    });
+
+    it('매우 오래된 기억은 낮은 점수를 받는다', () => {
+      const veryOld = ranking.calculateRecency(
+        new Date(Date.now() - 1000 * 24 * 60 * 60 * 1000),
+        'semantic'
+      );
+      expect(veryOld).toBeLessThan(0.1); // 1000일 전의 기억은 0.1보다 작은 점수
+    });
+  });
+
+  describe('calculateImportance', () => {
+    it('고정된 중요 기억은 부스트를 받아 점수가 상승한다', () => {
+      const base = ranking.calculateImportance(0.4, false, 'episodic');
+      const pinned = ranking.calculateImportance(0.4, true, 'episodic');
+      const semantic = ranking.calculateImportance(0.4, false, 'semantic');
+
+      expect(pinned).toBeGreaterThan(base);
+      expect(semantic).toBeGreaterThan(base);
+      expect(pinned).toBeLessThanOrEqual(1);
+    });
+
+    it('타입별로 다른 부스트를 적용한다', () => {
+      const working = ranking.calculateImportance(0.5, false, 'working');
+      const episodic = ranking.calculateImportance(0.5, false, 'episodic');
+      const semantic = ranking.calculateImportance(0.5, false, 'semantic');
+      const procedural = ranking.calculateImportance(0.5, false, 'procedural');
+
+      expect(working).toBeLessThan(episodic);
+      expect(episodic).toBeLessThan(procedural);
+      expect(procedural).toBeLessThan(semantic);
+    });
+
+    it('중요도는 0과 1 사이로 제한된다', () => {
+      const low = ranking.calculateImportance(-0.5, false, 'episodic');
+      const high = ranking.calculateImportance(1.5, false, 'episodic');
+
+      expect(low).toBeGreaterThanOrEqual(0);
+      expect(high).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('calculateUsage', () => {
+    it('접근 이력이 없는 경우 기본 사용성 점수를 적용한다', () => {
+      const metrics = { viewCount: 0, citeCount: 0, editCount: 0 };
+      expect(ranking.calculateUsage(metrics)).toBeCloseTo(0.1, 5);
+    });
+
+    it('다양한 사용성 메트릭을 올바르게 계산한다', () => {
+      const metrics = { viewCount: 10, citeCount: 5, editCount: 2 };
+      const usage = ranking.calculateUsage(metrics);
+      expect(usage).toBeGreaterThan(0.1);
+      expect(usage).toBeLessThanOrEqual(1);
+    });
+
+    it('배치 정규화가 적용된 사용성 점수를 계산한다', () => {
+      const metrics = { viewCount: 10, citeCount: 5, editCount: 2 };
+      const usage = ranking.calculateUsage(metrics, 0, 20);
+      expect(usage).toBeGreaterThanOrEqual(0);
+      expect(usage).toBeLessThanOrEqual(1);
+    });
+
+    it('null 입력에 대해 안전하게 처리한다', () => {
+      const usage = ranking.calculateUsage(null as any);
+      expect(usage).toBe(0);
+    });
+
+    it('모든 메트릭이 0인 경우 기본값을 반환한다', () => {
+      const metrics = { viewCount: 0, citeCount: 0, editCount: 0 };
+      const usage = ranking.calculateUsage(metrics);
+      expect(usage).toBeCloseTo(0.1, 5);
+    });
+  });
+
+  describe('calculateBatchUsage', () => {
+    it('여러 메모리에 대한 배치 사용성 점수를 계산한다', () => {
+      const metricsList = [
+        { viewCount: 10, citeCount: 5, editCount: 2 },
+        { viewCount: 20, citeCount: 10, editCount: 4 },
+        { viewCount: 5, citeCount: 2, editCount: 1 }
+      ];
+      
+      const result = ranking.calculateBatchUsage(metricsList);
+      expect(result.normalized).toHaveLength(3);
+      expect(result.min).toBeLessThanOrEqual(result.max);
+      expect(result.normalized.every(score => score >= 0 && score <= 1)).toBe(true);
+    });
+
+    it('빈 배열에 대해 안전하게 처리한다', () => {
+      const result = ranking.calculateBatchUsage([]);
+      expect(result.normalized).toHaveLength(0);
+    });
+  });
+
+  describe('calculateDuplicationPenalty', () => {
+    it('중복 패널티는 선택된 콘텐츠와의 최대 유사도를 반영한다', () => {
+      const penalty = ranking.calculateDuplicationPenalty(
+        'TypeScript Generic Tutorial',
+        ['React Hook Guide', 'TypeScript Advanced Generic Tutorial']
+      );
+
+      expect(penalty).toBeGreaterThan(0);
+      expect(penalty).toBeLessThan(1);
+    });
+
+    it('선택된 콘텐츠가 없으면 패널티가 0이다', () => {
+      const penalty = ranking.calculateDuplicationPenalty(
+        'TypeScript Generic Tutorial',
+        []
+      );
+      expect(penalty).toBe(0);
+    });
+
+    it('완전히 다른 콘텐츠는 낮은 패널티를 받는다', () => {
+      const penalty = ranking.calculateDuplicationPenalty(
+        'React Hook Guide',
+        ['Python Machine Learning', 'Database Design Patterns']
+      );
+      expect(penalty).toBeLessThan(0.5);
+    });
+  });
+
+  describe('하위 호환성 메서드들', () => {
+    it('calculateRelevanceSimple이 올바르게 작동한다', () => {
+      const relevance = ranking.calculateRelevanceSimple(
+        'React Hook',
+        'React Hook에 대한 내용',
+        ['react', 'hook']
+      );
+      expect(relevance).toBeGreaterThan(0);
+    });
+
+    it('calculateUsageSimple이 올바르게 작동한다', () => {
+      const recentDate = new Date(Date.now() - 1 * 24 * 60 * 60 * 1000);
+      const usage = ranking.calculateUsageSimple(recentDate);
+      expect(usage).toBeGreaterThan(0);
+    });
+
+    it('calculateUsageSimple에서 lastAccessed가 없으면 기본값을 반환한다', () => {
+      const usage = ranking.calculateUsageSimple(undefined);
+      expect(usage).toBeCloseTo(0.1, 5);
+    });
+  });
+
+  describe('엣지 케이스들', () => {
+    it('0으로 나누기 상황을 안전하게 처리한다', () => {
+      const usage = ranking.calculateUsage(
+        { viewCount: 0, citeCount: 0, editCount: 0 },
+        0, 0 // min과 max가 같을 때
+      );
+      // rawUsage가 0이므로 기본값 0.1을 반환
+      expect(usage).toBe(0.1);
+    });
+
+    it('매우 큰 값들에 대해 안전하게 처리한다', () => {
+      const relevance = ranking.calculateRelevance({
+        query: 'a'.repeat(10000),
+        content: 'b'.repeat(10000),
+        tags: Array(1000).fill('tag')
+      });
+      expect(relevance).toBeGreaterThanOrEqual(0);
+      expect(relevance).toBeLessThanOrEqual(1);
+    });
+  });
+});