memento-mcp-server 1.16.1 → 1.16.2-a

package/dist/domains/anchor/services/anchor/anchor-search-service.js

@@ -6,6 +6,13 @@
 import { UnifiedEmbeddingService } from '../../../embedding/services/unified-embedding-service.js';
 import { logger } from '../../../../shared/utils/logger.js';
 import { RelationGraph } from '../../../relation/services/relation-graph.js';
+import { NHopSearchService } from './n-hop-search-service.js';
+import { QueryFilterService } from './query-filter-service.js';
+import { FallbackSearchService } from './fallback-search-service.js';
+import { LocalSearchService } from './local-search-service.js';
+import { NHopSearchStrategy } from './n-hop-search-strategy.js';
+import { QueryFilterStrategy } from './query-filter-strategy.js';
+import { FallbackStrategy } from './fallback-strategy.js';
 /**
  * Anchor Search Service 구현
  */
@@ -16,11 +23,21 @@ export class AnchorSearchService {
     vectorSearchEngine = null;
     queryEmbeddingService = new UnifiedEmbeddingService();
     relationGraph = null;
+    // Phase 2.3-2.5: 분리된 서비스들
+    nHopSearchService;
+    queryFilterService;
+    fallbackSearchService;
+    // Phase 3.6: LocalSearchService
+    localSearchService = null;
     /**
      * 생성자
      */
     constructor(cacheService) {
         this.cacheService = cacheService;
+        // Phase 2.3-2.5: 분리된 서비스들 초기화
+        this.nHopSearchService = new NHopSearchService(cacheService);
+        this.queryFilterService = new QueryFilterService(cacheService);
+        this.fallbackSearchService = new FallbackSearchService();
         logger.info('AnchorSearchService 초기화 완료');
     }
     /**
@@ -28,6 +45,8 @@ export class AnchorSearchService {
      */
     setRelationGraph(relationGraph) {
         this.relationGraph = relationGraph;
+        // Phase 2.3: N-hop 검색 서비스에도 관계 그래프 설정
+        this.nHopSearchService.setRelationGraph(relationGraph);
     }
     /**
      * 데이터베이스 설정
@@ -37,6 +56,17 @@ export class AnchorSearchService {
             throw new Error('Database instance is required');
         }
         this.db = db;
+        // Phase 2.3-2.5: 분리된 서비스들에도 데이터베이스 설정
+        this.nHopSearchService.setDatabase(db);
+        this.fallbackSearchService.setDatabase(db);
+        // Phase 3.6: LocalSearchService 초기화
+        if (!this.localSearchService) {
+            const nHopSearchStrategy = new NHopSearchStrategy(this.nHopSearchService);
+            const queryFilterStrategy = new QueryFilterStrategy(this.queryFilterService);
+            const fallbackStrategy = new FallbackStrategy(this.fallbackSearchService);
+            this.localSearchService = new LocalSearchService(this.cacheService, nHopSearchStrategy, queryFilterStrategy, fallbackStrategy);
+        }
+        this.localSearchService.setDatabase(db);
     }
     /**
      * 하이브리드 검색 엔진 설정
@@ -46,6 +76,8 @@ export class AnchorSearchService {
             throw new Error('HybridSearchEngine is required');
         }
         this.hybridSearchEngine = hybridSearchEngine;
+        // Phase 2.5: Fallback 검색 서비스에도 하이브리드 검색 엔진 설정
+        this.fallbackSearchService.setHybridSearchEngine(hybridSearchEngine);
     }
     /**
      * 벡터 검색 엔진 설정
@@ -59,15 +91,21 @@ export class AnchorSearchService {
         if (this.db) {
             this.vectorSearchEngine.initialize(this.db);
         }
+        // Phase 2.3: N-hop 검색 서비스에도 벡터 검색 엔진 설정
+        this.nHopSearchService.setVectorSearchEngine(vectorSearchEngine);
     }
     /**
      * 국소 검색
      * 앵커 메모리를 기준으로 N-hop 제한 검색 수행
+     * Phase 3.7: LocalSearchService를 사용하도록 리팩토링
      */
     async searchLocal(agentId, slot, query, hopLimit, options, anchorMemoryId, anchorEmbedding, startTime) {
         if (!this.db) {
             throw new Error('Database is not set. Call setDatabase() first.');
         }
+        if (!this.localSearchService) {
+            throw new Error('LocalSearchService is not initialized. Call setDatabase() first.');
+        }
         // 슬롯별 설정 가져오기
         const slotConfig = this.getSlotConfig(slot);
         const finalHopLimit = hopLimit ?? slotConfig.hop_limit;
@@ -80,16 +118,15 @@ export class AnchorSearchService {
         if (!this.vectorSearchEngine) {
             throw new Error('VectorSearchEngine is not set. Call setVectorSearchEngine() first.');
         }
-        // N-hop 검색 구현 (use_relations 옵션에 따라 관계 그래프 사용 여부 결정)
-        const allHopResults = await this.searchNHop(anchorEmbedding.embedding, anchorEmbedding.provider, anchorMemoryId, vectorThreshold, finalHopLimit, limit * 2, // 더 많이 가져와서 필터링 후 최종 limit 적용
-        useRelations // 관계 그래프 사용 여부 전달
-        );
-        // 쿼리가 있는 경우 쿼리 기반 필터링
-        let filteredResults = allHopResults;
+        // Phase 3.6: LocalSearchService를 사용하여 파이프라인 실행
+        // 1. N-hop 검색 수행
+        const allHopResults = await this.localSearchService.performNHopSearch(anchorEmbedding.embedding, anchorEmbedding.provider, anchorMemoryId, vectorThreshold, finalHopLimit, limit * 2, // 더 많이 가져와서 필터링 후 최종 limit 적용
+        useRelations);
+        // 2. 쿼리 필터링 적용
+        const filteredResults = await this.localSearchService.applyQueryFilter(query, allHopResults, anchorEmbedding.provider);
+        // 자동 앵커 이동을 위한 쿼리 임베딩 생성 (선택적, 비동기)
         let queryEmbeddingForReanchor;
         if (query && query.trim().length > 0) {
-            filteredResults = await this.filterByQuery(query, allHopResults, anchorEmbedding.provider);
-            // 자동 앵커 이동을 위한 쿼리 임베딩 생성 (선택적, 비동기)
             try {
                 const queryEmbeddingResult = await this.queryEmbeddingService.generateEmbedding(query);
                 if (queryEmbeddingResult && queryEmbeddingResult.embedding) {
@@ -103,7 +140,7 @@ export class AnchorSearchService {
                 });
             }
         }
-        // 결과 포맷팅
+        // 3. 결과 포맷팅
         const formattedResults = filteredResults.map(result => ({
             id: result.memory_id,
             content: result.content,
@@ -117,58 +154,14 @@ export class AnchorSearchService {
         // 최종 limit 적용
         const localResults = formattedResults.slice(0, limit);
         const localCount = localResults.length;
-        // Fallback 체크 (query가 있을 때만, min_results 미만 시)
-        let fallbackUsed = false;
-        let finalResults = localResults;
-        let totalCount = localCount;
-        if (query && query.trim().length > 0 && localCount < minResults) {
-            try {
-                logger.info('Fallback to global search', {
-                    localCount,
-                    minResults
-                });
-                // Fallback 수행
-                const fallbackResult = await this.fallbackToGlobalSearch(query, { ...options, limit: limit - localCount }, // 부족한 만큼만 가져오기
-                startTime);
-                fallbackUsed = true;
-                // Local 결과와 Fallback 결과 병합
-                // Local 결과를 우선하고, 중복 제거 (memory_id 기준)
-                const localMemoryIds = new Set(localResults.map(r => r.id));
-                const fallbackItems = fallbackResult.items
-                    .filter(item => !localMemoryIds.has(item.id))
-                    .map(item => ({
-                    id: item.id,
-                    content: item.content,
-                    type: item.type,
-                    similarity: item.similarity ?? 0,
-                    hop_distance: item.hop_distance ?? 999, // fallback 결과는 hop_distance가 없으므로 큰 값으로 설정
-                    importance: item.importance ?? 0.5,
-                    created_at: item.created_at ?? new Date().toISOString(),
-                    tags: item.tags ?? undefined
-                }));
-                // Local 결과 + Fallback 결과 (중복 제거된 것만)
-                finalResults = [...localResults, ...fallbackItems].slice(0, limit);
-                totalCount = finalResults.length;
-                logger.info('Fallback completed', {
-                    localCount,
-                    fallbackCount: fallbackItems.length,
-                    totalCount
-                });
-            }
-            catch (error) {
-                logger.error('Fallback failed', {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-                // Fallback 실패 시 local 결과만 반환
-                fallbackUsed = false;
-            }
-        }
+        // 4. Fallback 처리
+        const fallbackResult = await this.localSearchService.handleFallback(query, localResults, minResults, options, startTime);
         const queryTime = Date.now() - startTime;
         return {
-            items: finalResults,
-            total_count: totalCount,
+            items: fallbackResult.items,
+            total_count: fallbackResult.totalCount,
             local_results_count: localCount,
-            fallback_used: fallbackUsed,
+            fallback_used: fallbackResult.fallbackUsed,
             query_time: queryTime,
             anchor_info: {
                 agent_id: agentId,
@@ -178,493 +171,19 @@ export class AnchorSearchService {
         };
     }
     /**
-     * 1-hop 검색: 앵커와 직접적으로 유사한 메모리 검색
-     */
-    async searchOneHop(anchorEmbedding, provider, anchorMemoryId, threshold, limit) {
-        if (!this.vectorSearchEngine || !this.db) {
-            throw new Error('VectorSearchEngine or Database is not set.');
-        }
-        try {
-            // VectorSearchEngine 초기화 확인
-            if (typeof this.vectorSearchEngine.initialize === 'function') {
-                this.vectorSearchEngine.initialize(this.db);
-            }
-            // 벡터 검색 실행 (임계값은 낮게 설정하고 나중에 필터링)
-            const searchResults = await this.vectorSearchEngine.search(anchorEmbedding, {
-                limit: limit + 1, // 자기 자신 제외를 위해 +1
-                threshold: 0.0, // 임계값은 나중에 필터링에서 적용
-                includeContent: true,
-                includeMetadata: true
-            }, provider);
-            // 결과 필터링: 앵커 메모리 제외, 유사도 임계값 이상만 반환
-            const filteredResults = searchResults
-                .filter(result => {
-                // 앵커 메모리 제외
-                if (result.memory_id === anchorMemoryId) {
-                    return false;
-                }
-                // 유사도 임계값 이상만 반환
-                return result.similarity >= threshold;
-            })
-                .slice(0, limit); // 최종 limit 적용
-            return filteredResults;
-        }
-        catch (error) {
-            logger.error('1-hop search failed', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw new Error(`Failed to perform 1-hop search: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * N-hop 검색: 앵커를 기준으로 최대 N-hop까지 확장 검색
-     */
-    async searchNHop(anchorEmbedding, provider, anchorMemoryId, threshold, maxHops, limit, useRelations = true) {
-        if (!this.vectorSearchEngine || !this.db) {
-            throw new Error('VectorSearchEngine or Database is not set.');
-        }
-        // VectorSearchEngine 초기화 확인
-        if (typeof this.vectorSearchEngine.initialize === 'function') {
-            this.vectorSearchEngine.initialize(this.db);
-        }
-        // 이미 발견된 메모리 ID 추적 (중복 방지)
-        const discoveredMemoryIds = new Set([anchorMemoryId]);
-        // 각 hop 레벨의 결과를 저장
-        const allResults = [];
-        // 현재 hop 레벨의 메모리들 (임베딩 포함)
-        // 1-hop: 앵커 임베딩을 사용
-        let currentHopMemories = [
-            { memory_id: anchorMemoryId, embedding: anchorEmbedding }
-        ];
-        // 각 hop 레벨별로 검색 수행
-        for (let hop = 1; hop <= maxHops; hop++) {
-            const nextHopMemories = [];
-            const hopResults = [];
-            // 현재 hop의 각 메모리에 대해 검색 수행
-            for (const currentMemory of currentHopMemories) {
-                try {
-                    // 관계 그래프 또는 memory_link를 활용한 직접 연결된 메모리 조회
-                    // use_relations가 false이면 관계 그래프를 사용하지 않음
-                    const linkedMemories = useRelations
-                        ? await this.getLinkedMemories(currentMemory.memory_id)
-                        : [];
-                    // 벡터 검색 실행
-                    const vectorSearchResults = await this.vectorSearchEngine.search(currentMemory.embedding, {
-                        limit: Math.ceil(limit / maxHops) + 10, // 각 hop당 충분한 결과 가져오기
-                        threshold: 0.0, // 임계값은 나중에 필터링에서 적용
-                        includeContent: true,
-                        includeMetadata: true
-                    }, provider);
-                    // memory_link 결과와 벡터 검색 결과를 병합
-                    const allCandidates = new Map();
-                    // memory_link 결과 추가 (우선순위 높음)
-                    for (const linked of linkedMemories) {
-                        if (!discoveredMemoryIds.has(linked.memory_id)) {
-                            allCandidates.set(linked.memory_id, {
-                                ...linked,
-                                isLinked: true
-                            });
-                        }
-                    }
-                    // 벡터 검색 결과 추가
-                    const relaxedThreshold = threshold * 0.5;
-                    for (const result of vectorSearchResults) {
-                        if (!allCandidates.has(result.memory_id) && !discoveredMemoryIds.has(result.memory_id)) {
-                            if (result.similarity >= relaxedThreshold) {
-                                allCandidates.set(result.memory_id, {
-                                    ...result,
-                                    isLinked: false
-                                });
-                            }
-                        }
-                        else if (allCandidates.has(result.memory_id)) {
-                            // memory_link로 이미 추가된 경우, 유사도 정보 업데이트
-                            const existing = allCandidates.get(result.memory_id);
-                            existing.similarity = Math.max(existing.similarity, result.similarity);
-                        }
-                    }
-                    // 결과 필터링 및 추가
-                    for (const [memoryId, candidate] of allCandidates.entries()) {
-                        if (discoveredMemoryIds.has(memoryId)) {
-                            continue;
-                        }
-                        const effectiveThreshold = candidate.isLinked
-                            ? threshold * 0.8
-                            : threshold;
-                        if (candidate.similarity < effectiveThreshold) {
-                            continue;
-                        }
-                        discoveredMemoryIds.add(memoryId);
-                        hopResults.push({
-                            memory_id: candidate.memory_id,
-                            content: candidate.content,
-                            type: candidate.type,
-                            similarity: candidate.similarity,
-                            importance: candidate.importance,
-                            created_at: candidate.created_at,
-                            tags: candidate.tags,
-                            hasRelation: candidate.isLinked // 관계가 있는 기억 표시
-                        });
-                        // 다음 hop을 위한 임베딩 조회
-                        if (hop < maxHops) {
-                            try {
-                                const nextEmbedding = await this.cacheService.getAnchorEmbedding(candidate.memory_id);
-                                if (nextEmbedding && nextEmbedding.embedding) {
-                                    nextHopMemories.push({
-                                        memory_id: candidate.memory_id,
-                                        embedding: nextEmbedding.embedding
-                                    });
-                                }
-                            }
-                            catch (error) {
-                                // 임베딩 조회 실패 시 다음 hop에서 제외
-                                logger.debug('Skipping memory for next hop (no embedding)', {
-                                    memoryId: candidate.memory_id,
-                                    error: error instanceof Error ? error.message : String(error)
-                                });
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    logger.error('Hop search failed', {
-                        hop,
-                        memoryId: currentMemory.memory_id,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                    continue;
-                }
-            }
-            // 현재 hop의 결과를 전체 결과에 추가
-            for (const result of hopResults) {
-                allResults.push({
-                    ...result,
-                    hop_distance: hop,
-                    hasRelation: result.hasRelation ?? false
-                });
-            }
-            // limit에 도달했으면 중단
-            if (allResults.length >= limit) {
-                break;
-            }
-            // 다음 hop을 위한 메모리가 없으면 중단
-            if (nextHopMemories.length === 0) {
-                break;
-            }
-            // 다음 hop을 위한 메모리로 업데이트
-            currentHopMemories = nextHopMemories;
-        }
-        // 랭킹 점수 계산 및 적용 (관계 그래프 가중치 포함)
-        const rankedResults = await Promise.all(allResults.map(async (result) => {
-            // 관계 가중치 계산 (관계 그래프가 있고 use_relations가 true인 경우)
-            let relationWeight = 0;
-            let hasRelation = result.hasRelation ?? false;
-            if (useRelations && this.relationGraph) {
-                try {
-                    const relations = await this.relationGraph.getRelations(result.memory_id, {
-                        direction: 'both',
-                        minConfidence: 0.5
-                    });
-                    if (relations.length > 0) {
-                        hasRelation = true; // 관계가 있음을 표시
-                        // 관계 가중치 계산 (간단한 평균)
-                        const avgConfidence = relations.reduce((sum, r) => sum + r.confidence, 0) / relations.length;
-                        const avgBoost = relations.reduce((sum, r) => sum + this.getRelationTypeBoost(r.relation_type), 0) / relations.length;
-                        relationWeight = Math.min(1.0, avgConfidence * avgBoost);
-                    }
-                }
-                catch (error) {
-                    // 관계 조회 실패는 무시
-                    logger.debug('Relation weight calculation failed', {
-                        memoryId: result.memory_id,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            const rankingScore = this.calculateRankingScore(result.similarity, result.hop_distance, result.importance, relationWeight, hasRelation // 관계가 있는 기억에 우선순위 부여
-            );
-            return {
-                ...result,
-                similarity: rankingScore,
-                hasRelation
-            };
-        }));
-        // 랭킹 점수 기준으로 정렬 (관계가 있는 기억 우선)
-        rankedResults.sort((a, b) => {
-            // 관계가 있는 기억에 우선순위 부여
-            if (a.hasRelation && !b.hasRelation) {
-                return -1; // a가 우선
-            }
-            if (!a.hasRelation && b.hasRelation) {
-                return 1; // b가 우선
-            }
-            // 둘 다 관계가 있거나 둘 다 없는 경우, similarity 기준 정렬
-            if (Math.abs(a.similarity - b.similarity) < 0.001) {
-                return a.hop_distance - b.hop_distance;
-            }
-            return b.similarity - a.similarity;
-        });
-        // 최종 limit 적용
-        return rankedResults.slice(0, limit);
-    }
-    /**
-     * 쿼리 기반 필터링
-     */
-    async filterByQuery(query, results, provider) {
-        if (results.length === 0) {
-            return results;
-        }
-        try {
-            // 쿼리 임베딩 생성
-            const queryEmbeddingResult = await this.queryEmbeddingService.generateEmbedding(query);
-            if (!queryEmbeddingResult || !queryEmbeddingResult.embedding) {
-                logger.warn('Query embedding generation failed, skipping filter');
-                return results;
-            }
-            const queryEmbedding = queryEmbeddingResult.embedding;
-            // 각 결과 메모리의 임베딩 조회 및 쿼리 유사도 계산
-            const resultsWithQuerySimilarity = await Promise.all(results.map(async (result) => {
-                try {
-                    const memoryEmbedding = await this.cacheService.getAnchorEmbedding(result.memory_id);
-                    if (!memoryEmbedding || !memoryEmbedding.embedding) {
-                        return {
-                            ...result,
-                            query_similarity: 0,
-                            combined_similarity: result.similarity * 0.5
-                        };
-                    }
-                    // 쿼리 임베딩과 메모리 임베딩 간 유사도 계산
-                    let querySim = 0;
-                    if (queryEmbedding.length === memoryEmbedding.embedding.length) {
-                        querySim = this.cosineSimilarity(queryEmbedding, memoryEmbedding.embedding);
-                    }
-                    else {
-                        // 차원이 다르면 텍스트 기반 간단한 매칭
-                        const queryLower = query.toLowerCase();
-                        const contentLower = result.content.toLowerCase();
-                        const queryWords = queryLower.split(/\s+/);
-                        const matchCount = queryWords.filter(word => contentLower.includes(word)).length;
-                        querySim = matchCount / Math.max(queryWords.length, 1);
-                    }
-                    const baseRankingScore = this.calculateRankingScore(result.similarity, result.hop_distance, result.importance, 0 // query filtering에서는 관계 가중치 미사용 (이미 searchNHop에서 적용됨)
-                    );
-                    const combinedSimilarity = baseRankingScore * 0.6 + querySim * 0.4;
-                    return {
-                        ...result,
-                        query_similarity: querySim,
-                        combined_similarity: combinedSimilarity
-                    };
-                }
-                catch (error) {
-                    logger.error('Query filtering failed for memory', {
-                        memoryId: result.memory_id,
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                    return {
-                        ...result,
-                        query_similarity: 0,
-                        combined_similarity: result.similarity * 0.5
-                    };
-                }
-            }));
-            // 쿼리 유사도 임계값 적용
-            const queryThreshold = 0.3;
-            const filtered = resultsWithQuerySimilarity.filter(r => r.query_similarity >= queryThreshold || r.combined_similarity >= 0.5);
-            // 결합 유사도 기준으로 재정렬
-            filtered.sort((a, b) => {
-                if (Math.abs(a.combined_similarity - b.combined_similarity) < 0.001) {
-                    return a.hop_distance - b.hop_distance;
-                }
-                return b.combined_similarity - a.combined_similarity;
-            });
-            // 원본 similarity를 combined_similarity로 업데이트하여 반환
-            return filtered.map(r => ({
-                ...r,
-                similarity: r.combined_similarity
-            }));
-        }
-        catch (error) {
-            logger.error('Query-based filtering failed', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return results;
-        }
-    }
-    /**
-     * 전역 검색으로 Fallback
-     */
-    async fallbackToGlobalSearch(query, options, startTime) {
-        if (!this.hybridSearchEngine) {
-            throw new Error('HybridSearchEngine is not set. Call setHybridSearchEngine() first.');
-        }
-        if (!this.db) {
-            throw new Error('Database is not set.');
-        }
-        const limit = options?.limit ?? 10;
-        const fallbackStartTime = Date.now();
-        try {
-            // HybridSearchEngine을 사용한 전역 검색
-            const globalSearchResult = await this.hybridSearchEngine.search(this.db, {
-                query: query,
-                limit: limit,
-                vectorWeight: options?.vector_weight,
-                textWeight: options?.text_weight
-            });
-            // HybridSearchResult를 SearchResult 형식으로 변환
-            const convertedItems = globalSearchResult.items.map(item => ({
-                id: item.id,
-                content: item.content,
-                type: item.type,
-                similarity: item.finalScore,
-                importance: item.importance,
-                created_at: item.created_at,
-                tags: item.tags,
-                hop_distance: undefined
-            }));
-            const queryTime = startTime ? Date.now() - startTime : Date.now() - fallbackStartTime;
-            return {
-                items: convertedItems,
-                total_count: convertedItems.length,
-                local_results_count: 0,
-                fallback_used: true,
-                query_time: queryTime
-            };
-        }
-        catch (error) {
-            logger.error('Global search fallback failed', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            const queryTime = startTime ? Date.now() - startTime : 0;
-            return {
-                items: [],
-                total_count: 0,
-                local_results_count: 0,
-                fallback_used: true,
-                query_time: queryTime
-            };
-        }
-    }
-    /**
-     * memory_link 테이블을 활용한 직접 연결된 메모리 조회
-     */
-    /**
-     * 연결된 메모리 조회
-     * 관계 그래프가 있으면 우선 사용, 없으면 memory_link 사용
-     */
-    async getLinkedMemories(memoryId) {
-        if (!this.db) {
-            return [];
-        }
-        try {
-            // 관계 그래프가 있으면 우선 사용
-            if (this.relationGraph) {
-                const relations = await this.relationGraph.getRelations(memoryId, {
-                    direction: 'outgoing',
-                    minConfidence: 0.5
-                });
-                if (relations.length > 0) {
-                    // 관계를 메모리 정보와 결합
-                    const memoryIds = relations.map(r => r.target_id);
-                    const placeholders = memoryIds.map(() => '?').join(',');
-                    const memoryRecords = this.db.prepare(`
-            SELECT id, content, type, importance, created_at, tags
-            FROM memory_item
-            WHERE id IN (${placeholders})
-          `).all(...memoryIds);
-                    // 관계 정보와 메모리 정보 결합
-                    const memoryMap = new Map(memoryRecords.map(m => [m.id, m]));
-                    return relations.map(relation => {
-                        const memory = memoryMap.get(relation.target_id);
-                        if (!memory) {
-                            return null;
-                        }
-                        // 관계 confidence를 similarity로 사용 (관계가 있으면 높은 유사도)
-                        // 관계 유형별 부스트 적용
-                        const typeBoost = this.getRelationTypeBoost(relation.relation_type);
-                        const similarity = Math.min(1.0, relation.confidence * typeBoost);
-                        return {
-                            memory_id: memory.id,
-                            content: memory.content,
-                            type: memory.type,
-                            similarity,
-                            importance: memory.importance,
-                            created_at: memory.created_at,
-                            tags: memory.tags ? JSON.parse(memory.tags) : undefined
-                        };
-                    }).filter((item) => item !== null);
-                }
-            }
-            // 관계 그래프가 없거나 관계가 없으면 memory_link 사용 (하위 호환성)
-            const linkedRecords = this.db.prepare(`
-        SELECT 
-          ml.target_id as memory_id,
-          mi.content,
-          mi.type,
-          mi.importance,
-          mi.created_at,
-          mi.tags,
-          ml.relation_type
-        FROM memory_link ml
-        JOIN memory_item mi ON mi.id = ml.target_id
-        WHERE ml.source_id = ?
-        ORDER BY ml.created_at DESC
-      `).all(memoryId);
-            return linkedRecords.map(record => ({
-                memory_id: record.memory_id,
-                content: record.content,
-                type: record.type,
-                similarity: 0.9, // memory_link는 기본 유사도 0.9
-                importance: record.importance,
-                created_at: record.created_at,
-                tags: record.tags ? (typeof record.tags === 'string' ? JSON.parse(record.tags) : record.tags) : undefined
-            }));
-        }
-        catch (error) {
-            logger.error('memory_link retrieval failed', {
-                memoryId,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            return [];
-        }
-    }
-    /**
-     * 관계 유형별 부스트 가중치 반환
+     * 슬롯별 설정 조회
      */
-    getRelationTypeBoost(relationType) {
-        const boostMap = {
-            'CAUSES': 1.2,
-            'DEPENDS_ON': 1.1,
-            'FOLLOWS': 1.0,
-            'CONTRASTS_WITH': 0.9,
-            'REFERENCES': 0.8,
-            'BELONGS_TO': 1.0
+    getSlotConfig(slot) {
+        const slotConfig = {
+            A: { hop_limit: 1, vector_threshold: 0.8 },
+            B: { hop_limit: 2, vector_threshold: 0.6 },
+            C: { hop_limit: 3, vector_threshold: 0.4 }
         };
-        return boostMap[relationType] || 1.0;
-    }
-    /**
-     * 검색 결과 랭킹 점수 계산
-     * 관계 그래프와 벡터 유사도를 결합한 하이브리드 hop 점수 계산
-     * 관계가 있는 기억에 우선순위 부여
-     */
-    calculateRankingScore(similarity, hopDistance, importance = 0.5, relationWeight = 0, hasRelation = false) {
-        const hopDecayFactor = 1.0 / (1.0 + (hopDistance - 1) * 0.3);
-        const anchorProximityBoost = hopDistance === 1 ? 1.2 : 1.0;
-        const importanceWeight = 0.1;
-        const importanceBoost = 1.0 + (importance - 0.5) * importanceWeight;
-        // 관계 가중치가 있으면 벡터 유사도와 결합
-        let combinedSimilarity = similarity;
-        if (relationWeight > 0) {
-            // 관계 가중치와 벡터 유사도를 가중 평균으로 결합
-            // 관계 가중치: 30%, 벡터 유사도: 70%
-            combinedSimilarity = similarity * 0.7 + relationWeight * 0.3;
-        }
-        // 관계가 있는 기억에 우선순위 부스트 적용
-        const relationPriorityBoost = hasRelation ? 1.15 : 1.0; // 15% 부스트
-        const rankingScore = Math.min(1.0, combinedSimilarity * hopDecayFactor * anchorProximityBoost * importanceBoost * relationPriorityBoost);
-        return rankingScore;
+        return slotConfig[slot];
     }
     /**
      * 코사인 유사도 계산
+     * Phase 2.7.3: calculateReanchorScore에서 사용하므로 유지
      */
     cosineSimilarity(a, b) {
         if (a.length !== b.length) {
@@ -684,15 +203,11 @@ export class AnchorSearchService {
         return magnitude === 0 ? 0 : dotProduct / magnitude;
     }
     /**
-     * 슬롯별 설정 조회
+     * 전역 검색으로 Fallback
+     * Phase 2.5: FallbackSearchService 위임
      */
-    getSlotConfig(slot) {
-        const slotConfig = {
-            A: { hop_limit: 1, vector_threshold: 0.8 },
-            B: { hop_limit: 2, vector_threshold: 0.6 },
-            C: { hop_limit: 3, vector_threshold: 0.4 }
-        };
-        return slotConfig[slot];
+    async fallbackToGlobalSearch(query, options, startTime) {
+        return this.fallbackSearchService.fallbackToGlobalSearch(query, options, startTime);
     }
     /**
      * 자동 앵커 이동 점수 계산
@@ -767,7 +282,9 @@ export class AnchorSearchService {
         }
         try {
             const slotConfig = this.getSlotConfig(slot);
-            const nearbyMemories = await this.searchNHop(anchorEmbedding.embedding, anchorEmbedding.provider, anchorMemoryId, slotConfig.vector_threshold * 0.8, slotConfig.hop_limit, 20);
+            // Phase 2.3: N-hop 검색 서비스 사용
+            const nearbyMemories = await this.nHopSearchService.searchNHop(anchorEmbedding.embedding, anchorEmbedding.provider, anchorMemoryId, slotConfig.vector_threshold * 0.8, slotConfig.hop_limit, 20, true // useRelations 기본값
+            );
             const candidates = [];
             for (const memory of nearbyMemories) {
                 const score = await this.calculateReanchorScore(memory.memory_id, queryEmbedding, anchorEmbedding.embedding);