memento-mcp-server 1.11.0-a1 → 1.11.1-a

package/dist/services/anchor-manager.js

@@ -1,54 +1,25 @@
 /**
- * Anchor Manager Service
- * 앵커 상태 관리 및 국소 검색 기능 제공
+ * Anchor Manager Service (하위 호환성 래퍼)
+ * 새로운 구조로 리팩토링된 서비스들을 통합하여 기존 인터페이스 유지
+ * Phase 1.1: anchor-manager.ts 리팩토링
  *
- * 클린코드 원칙:
- * - 단일 책임 원칙: 앵커 상태 관리 및 국소 검색만 담당
- * - 의존성 역전: Database와 다른 서비스에 의존
- * - 캐시 최적화: 메모리 캐시를 통한 빠른 읽기 접근
+ * @deprecated 새로운 구조에서는 src/services/anchor/ 디렉토리의 서비스들을 직접 사용하세요
  */
 import { getVectorSearchEngine } from '../algorithms/vector-search-engine.js';
-import { UnifiedEmbeddingService } from './unified-embedding-service.js';
+import { AnchorManager as NewAnchorManager } from './anchor/anchor-manager.js';
+import { AnchorCacheService } from './anchor/anchor-cache-service.js';
+import { AnchorSearchService } from './anchor/anchor-search-service.js';
+import { AnchorError, MemoryNotFoundError } from './anchor/anchor-interfaces.js';
+import { logger } from '../utils/logger.js';
+export { AnchorError, MemoryNotFoundError };
 /**
- * 앵커 설정 에러
- */
-export class AnchorError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'AnchorError';
-    }
-}
-/**
- * 메모리를 찾을 수 없을 때 발생하는 에러
- */
-export class MemoryNotFoundError extends Error {
-    constructor(memoryId) {
-        super(`Memory with ID '${memoryId}' not found`);
-        this.name = 'MemoryNotFoundError';
-    }
-}
-/**
- * Anchor Manager Service
- * 앵커 상태 관리 및 국소 검색 기능 제공
+ * Anchor Manager Service (하위 호환성 래퍼)
+ * 기존 인터페이스를 유지하면서 새로운 구조의 서비스들을 사용
  */
 export class AnchorManager {
-    /**
-     * 메모리 캐시: agent_id별 슬롯 상태 관리
-     * Map<agent_id, {A: memory_id | null, B: memory_id | null, C: memory_id | null}>
-     */
-    cache = new Map();
-    /**
-     * 쿼리 임베딩 서비스
-     */
-    queryEmbeddingService = new UnifiedEmbeddingService();
-    /**
-     * 슬롯별 설정
-     */
-    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 }
-    };
+    newAnchorManager;
+    cacheService;
+    searchService;
     db = null;
     embeddingService = null;
     hybridSearchEngine = null;
@@ -57,17 +28,23 @@ export class AnchorManager {
      * 생성자
      */
     constructor() {
-        console.log('✅ AnchorManager 서비스 초기화 완료');
+        // 새로운 구조의 서비스들 초기화
+        this.cacheService = new AnchorCacheService();
+        this.searchService = new AnchorSearchService(this.cacheService);
+        this.newAnchorManager = new NewAnchorManager(this.cacheService, this.searchService);
+        logger.info('AnchorManager 서비스 초기화 완료 (하위 호환성 래퍼)');
     }
     /**
      * 데이터베이스 설정
-     * @param db - 데이터베이스 인스턴스
      */
     setDatabase(db) {
         if (!db) {
             throw new Error('Database instance is required');
         }
         this.db = db;
+        this.newAnchorManager.setDatabase(db);
+        this.cacheService.setDatabase(db);
+        this.searchService.setDatabase(db);
         // VectorSearchEngine이 설정되어 있으면 초기화
         if (this.vectorSearchEngine) {
             this.vectorSearchEngine.initialize(db);
@@ -75,33 +52,33 @@ export class AnchorManager {
     }
     /**
      * 임베딩 서비스 설정
-     * @param embeddingService - 메모리 임베딩 서비스 인스턴스
      */
     setEmbeddingService(embeddingService) {
         if (!embeddingService) {
             throw new Error('MemoryEmbeddingService is required');
         }
         this.embeddingService = embeddingService;
+        this.cacheService.setEmbeddingService(embeddingService);
     }
     /**
      * 하이브리드 검색 엔진 설정
-     * @param hybridSearchEngine - 하이브리드 검색 엔진 인스턴스
      */
     setHybridSearchEngine(hybridSearchEngine) {
         if (!hybridSearchEngine) {
             throw new Error('HybridSearchEngine is required');
         }
         this.hybridSearchEngine = hybridSearchEngine;
+        this.searchService.setHybridSearchEngine(hybridSearchEngine);
     }
     /**
      * 벡터 검색 엔진 설정
-     * @param vectorSearchEngine - 벡터 검색 엔진 인스턴스
      */
     setVectorSearchEngine(vectorSearchEngine) {
         if (!vectorSearchEngine) {
             throw new Error('VectorSearchEngine is required');
         }
         this.vectorSearchEngine = vectorSearchEngine;
+        this.searchService.setVectorSearchEngine(vectorSearchEngine);
         // 데이터베이스가 이미 설정되어 있으면 초기화
         if (this.db) {
             this.vectorSearchEngine.initialize(this.db);
@@ -109,227 +86,92 @@ export class AnchorManager {
     }
     /**
      * 앵커 설정
-     * @param agentId - 에이전트 ID
-     * @param memoryId - 메모리 ID
-     * @param slot - 슬롯 (A, B, C)
-     * @throws {MemoryNotFoundError} 메모리가 존재하지 않는 경우
-     * @throws {AnchorError} 동일한 memory_id를 다른 슬롯에 이미 설정한 경우
      */
     async setAnchor(agentId, memoryId, slot) {
-        if (!this.db) {
-            throw new Error('Database is not set. Call setDatabase() first.');
-        }
-        // 메모리 존재 확인
-        const memory = this.db.prepare(`
-      SELECT id FROM memory_item WHERE id = ?
-    `).get(memoryId);
-        if (!memory) {
-            throw new MemoryNotFoundError(memoryId);
-        }
-        // 동일한 agent_id가 동일한 memory_id를 다른 슬롯에 이미 설정했는지 확인
-        const existingAnchor = this.db.prepare(`
-      SELECT slot FROM anchor 
-      WHERE agent_id = ? AND memory_id = ? AND slot != ?
-    `).get(agentId, memoryId, slot);
-        if (existingAnchor) {
-            throw new AnchorError(`Memory '${memoryId}' is already set as anchor in slot '${existingAnchor.slot}'. ` +
-                `An agent cannot set the same memory in multiple slots.`);
-        }
-        // 기존 앵커가 있으면 업데이트, 없으면 삽입
-        const existing = this.db.prepare(`
-      SELECT id FROM anchor WHERE agent_id = ? AND slot = ?
-    `).get(agentId, slot);
-        if (existing) {
-            // 업데이트
-            this.db.prepare(`
-        UPDATE anchor 
-        SET memory_id = ?, updated_at = CURRENT_TIMESTAMP
-        WHERE agent_id = ? AND slot = ?
-      `).run(memoryId, agentId, slot);
-        }
-        else {
-            // 삽입
-            this.db.prepare(`
-        INSERT INTO anchor (agent_id, slot, memory_id)
-        VALUES (?, ?, ?)
-      `).run(agentId, slot, memoryId);
-        }
-        // 캐시 업데이트
-        this.updateCache(agentId, slot, memoryId);
+        return this.newAnchorManager.setAnchor(agentId, memoryId, slot);
     }
     /**
      * 앵커 조회
-     * @param agentId - 에이전트 ID
-     * @param slot - 슬롯 (A, B, C), 선택적. 없으면 모든 슬롯 반환
-     * @returns 앵커 정보 또는 null
      */
     async getAnchor(agentId, slot) {
-        if (!this.db) {
-            throw new Error('Database is not set. Call setDatabase() first.');
-        }
-        // 캐시에서 먼저 확인
-        const cached = this.cache.get(agentId);
-        if (slot) {
-            // 특정 슬롯 조회
-            const cachedMemoryId = cached?.[slot];
-            if (cachedMemoryId !== undefined) {
-                // 캐시에 있으면 DB에서 상세 정보 조회
-                const anchor = this.db.prepare(`
-          SELECT agent_id, slot, memory_id, created_at, updated_at
-          FROM anchor
-          WHERE agent_id = ? AND slot = ?
-        `).get(agentId, slot);
-                return anchor || null;
-            }
-        }
-        else {
-            // 모든 슬롯 조회
-            if (cached) {
-                // 캐시에 있으면 DB에서 상세 정보 조회
-                const anchors = this.db.prepare(`
-          SELECT agent_id, slot, memory_id, created_at, updated_at
-          FROM anchor
-          WHERE agent_id = ?
-          ORDER BY slot
-        `).all(agentId);
-                return anchors;
-            }
-        }
-        // 캐시에 없으면 DB에서 조회 후 캐시 업데이트
-        if (slot) {
-            const anchor = this.db.prepare(`
-        SELECT agent_id, slot, memory_id, created_at, updated_at
-        FROM anchor
-        WHERE agent_id = ? AND slot = ?
-      `).get(agentId, slot);
-            if (anchor) {
-                this.updateCache(agentId, slot, anchor.memory_id);
-            }
-            return anchor || null;
-        }
-        else {
-            const anchors = this.db.prepare(`
-        SELECT agent_id, slot, memory_id, created_at, updated_at
-        FROM anchor
-        WHERE agent_id = ?
-        ORDER BY slot
-      `).all(agentId);
-            // 캐시 업데이트
-            for (const anchor of anchors) {
-                this.updateCache(anchor.agent_id, anchor.slot, anchor.memory_id);
-            }
-            return anchors.length > 0 ? anchors : null;
-        }
+        return this.newAnchorManager.getAnchor(agentId, slot);
     }
     /**
      * 앵커 제거
-     * @param agentId - 에이전트 ID
-     * @param slot - 슬롯 (A, B, C), 선택적. 없으면 모든 슬롯 제거
      */
     async clearAnchor(agentId, slot) {
-        if (!this.db) {
-            throw new Error('Database is not set. Call setDatabase() first.');
-        }
-        if (slot) {
-            // 특정 슬롯 제거
-            this.db.prepare(`
-        DELETE FROM anchor WHERE agent_id = ? AND slot = ?
-      `).run(agentId, slot);
-            // 캐시 업데이트
-            this.updateCache(agentId, slot, null);
-        }
-        else {
-            // 모든 슬롯 제거
-            this.db.prepare(`
-        DELETE FROM anchor WHERE agent_id = ?
-      `).run(agentId);
-            // 캐시에서 제거
-            this.cache.delete(agentId);
-        }
+        return this.newAnchorManager.clearAnchor(agentId, slot);
     }
     /**
      * 국소 검색
-     * 앵커 메모리를 기준으로 N-hop 제한 검색 수행
-     * @param agentId - 에이전트 ID
-     * @param slot - 슬롯 (A, B, C)
-     * @param query - 검색 쿼리 (선택적)
-     * @param hopLimit - Hop 제한 (선택적, 기본값: 슬롯별 설정값)
-     * @param options - 검색 옵션
-     * @returns 검색 결과
      */
     async searchLocal(agentId, slot, query, hopLimit, options) {
-        const startTime = Date.now();
         if (!this.db) {
             throw new Error('Database is not set. Call setDatabase() first.');
         }
         if (!this.embeddingService) {
             throw new Error('MemoryEmbeddingService is not set. Call setEmbeddingService() first.');
         }
+        const startTime = Date.now();
         // 앵커 조회
         const anchor = await this.getAnchor(agentId, slot);
         if (!anchor || Array.isArray(anchor) || !anchor.memory_id) {
-            // 앵커가 없거나 memory_id가 NULL인 경우 (Edge Case: 앵커 없음 또는 메모리 삭제)
-            console.warn(`⚠️ No anchor set for agent '${agentId}' in slot '${slot}' (memory_id is NULL)`);
+            logger.warn('No anchor set for agent', { agentId, slot });
             if (!query) {
-                // query가 없으면 에러 반환 (앵커 기반 리콜은 앵커가 필수)
                 throw new AnchorError(`No anchor set for agent '${agentId}' in slot '${slot}'. ` +
                     `Anchor is required for anchor-based recall. ` +
                     `If the anchor memory was deleted, please set a new anchor.`);
             }
             // query가 있으면 전역 검색으로 fallback
-            console.log(`🔄 Anchor missing, falling back to global search for query: "${query}"`);
-            return await this.fallbackToGlobalSearch(query, options, startTime);
+            logger.info('Anchor missing, falling back to global search', { query });
+            return await this.searchService.fallbackToGlobalSearch(query, options, startTime);
         }
         // 슬롯별 설정 가져오기
-        const slotConfig = this.getSlotConfig(slot);
+        const slotConfig = this.newAnchorManager.getSlotConfig(slot);
         const finalHopLimit = hopLimit ?? slotConfig.hop_limit;
-        const vectorThreshold = slotConfig.vector_threshold;
-        // 검색 옵션 기본값
-        const limit = options?.limit ?? 10;
-        const minResults = options?.min_results ?? 3;
-        // 앵커 메모리 임베딩 조회 (Edge Case: 임베딩 없음, 메모리 삭제)
-        let anchorEmbedding = await this.getAnchorEmbedding(anchor.memory_id);
+        // 앵커 메모리 임베딩 조회
+        let anchorEmbedding = await this.cacheService.getAnchorEmbedding(anchor.memory_id);
         if (!anchorEmbedding) {
             // 임베딩이 없으면 메모리 존재 확인 후 생성 시도
             const memory = this.db.prepare(`
         SELECT id, content, type FROM memory_item WHERE id = ?
       `).get(anchor.memory_id);
             if (!memory) {
-                // Edge Case: 메모리가 삭제된 경우
-                console.warn(`⚠️ Anchor memory '${anchor.memory_id}' not found (may have been deleted)`);
-                // 앵커를 자동으로 정리 (선택적)
+                logger.warn('Anchor memory not found (may have been deleted)', { memoryId: anchor.memory_id });
+                // 앵커를 자동으로 정리
                 try {
                     await this.clearAnchor(agentId, slot);
-                    console.log(`🧹 Cleared invalid anchor for agent '${agentId}' in slot '${slot}'`);
+                    logger.info('Cleared invalid anchor', { agentId, slot });
                 }
                 catch (error) {
-                    console.error(`❌ Failed to clear invalid anchor:`, error);
+                    logger.error('Failed to clear invalid anchor', {
+                        error: error instanceof Error ? error.message : String(error)
+                    });
                 }
                 // query가 있으면 전역 검색으로 fallback
                 if (query) {
-                    console.log(`🔄 Anchor memory deleted, falling back to global search for query: "${query}"`);
-                    return await this.fallbackToGlobalSearch(query, options, startTime);
+                    logger.info('Anchor memory deleted, falling back to global search', { query });
+                    return await this.searchService.fallbackToGlobalSearch(query, options, startTime);
                 }
                 // query가 없으면 에러 반환
                 throw new MemoryNotFoundError(anchor.memory_id +
                     ` (Memory may have been deleted. Please set a new anchor.)`);
             }
             // Edge Case: 임베딩 없음 - 생성 시도
-            console.log(`🔄 Generating embedding for anchor memory '${anchor.memory_id}'`);
+            logger.info('Generating embedding for anchor memory', { memoryId: anchor.memory_id });
             const embeddingResult = await this.embeddingService.createAndStoreEmbedding(this.db, memory.id, memory.content, memory.type);
             if (!embeddingResult) {
                 throw new Error(`Failed to generate embedding for anchor memory '${anchor.memory_id}'. ` +
                     `Please check if the embedding service is available.`);
             }
             // 생성된 임베딩 다시 조회
-            const newEmbedding = await this.getAnchorEmbedding(anchor.memory_id);
+            const newEmbedding = await this.cacheService.getAnchorEmbedding(anchor.memory_id);
             if (!newEmbedding) {
                 throw new Error(`Failed to retrieve newly created embedding for '${anchor.memory_id}'. ` +
                     `Please try again or check the database.`);
             }
-            // 새로 생성된 임베딩 사용
             anchorEmbedding = newEmbedding;
-            console.log(`✅ Embedding generated and retrieved for anchor memory '${anchor.memory_id}'`);
+            logger.info('Embedding generated and retrieved for anchor memory', { memoryId: anchor.memory_id });
         }
         // VectorSearchEngine이 없으면 생성
         if (!this.vectorSearchEngine) {
@@ -337,771 +179,56 @@ export class AnchorManager {
             if (this.db) {
                 this.vectorSearchEngine.initialize(this.db);
             }
+            this.searchService.setVectorSearchEngine(this.vectorSearchEngine);
         }
-        // N-hop 검색 구현
-        const allHopResults = await this.searchNHop(anchorEmbedding.embedding, anchorEmbedding.provider, anchor.memory_id, vectorThreshold, finalHopLimit, limit * 2 // 더 많이 가져와서 필터링 후 최종 limit 적용
-        );
-        // 쿼리가 있는 경우 쿼리 기반 필터링 (작업 3.7)
-        let filteredResults = allHopResults;
-        let queryEmbeddingForReanchor;
-        if (query && query.trim().length > 0) {
-            filteredResults = await this.filterByQuery(query, allHopResults, anchorEmbedding.provider);
-            // 자동 앵커 이동을 위한 쿼리 임베딩 생성 (선택적, 비동기)
+        // 검색 실행
+        const searchResult = await this.searchService.searchLocal(agentId, slot, query, finalHopLimit, options, anchor.memory_id, anchorEmbedding, startTime);
+        // 자동 앵커 이동 체크 (query가 있고 queryEmbeddingForReanchor가 생성된 경우)
+        if (query && options?.autoMoveEnabled !== false) {
             try {
-                const queryEmbeddingResult = await this.queryEmbeddingService.generateEmbedding(query);
+                // 쿼리 임베딩 생성
+                const { UnifiedEmbeddingService } = await import('./unified-embedding-service.js');
+                const queryEmbeddingService = new UnifiedEmbeddingService();
+                const queryEmbeddingResult = await queryEmbeddingService.generateEmbedding(query);
                 if (queryEmbeddingResult && queryEmbeddingResult.embedding) {
-                    queryEmbeddingForReanchor = queryEmbeddingResult.embedding;
+                    await this.searchService.checkAndAutoReanchor(agentId, slot, this.newAnchorManager, queryEmbeddingResult.embedding, true);
                 }
             }
-            catch (error) {
-                // 쿼리 임베딩 생성 실패는 무시 (자동 이동은 선택적)
-                console.debug('쿼리 임베딩 생성 실패 (자동 앵커 이동용):', error);
-            }
-        }
-        // 결과 포맷팅
-        const formattedResults = filteredResults.map(result => ({
-            id: result.memory_id,
-            content: result.content,
-            type: result.type,
-            similarity: result.similarity,
-            hop_distance: result.hop_distance,
-            importance: result.importance,
-            created_at: result.created_at,
-            tags: result.tags
-        }));
-        // 최종 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 {
-                console.log(`🔄 Fallback to global search: local results (${localCount}) < min_results (${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;
-                console.log(`✅ Fallback 완료: local ${localCount} + fallback ${fallbackItems.length} = total ${totalCount}`);
-            }
-            catch (error) {
-                console.error('❌ Fallback 실패:', error);
-                // Fallback 실패 시 local 결과만 반환
-                fallbackUsed = false;
-            }
-        }
-        // 자동 앵커 이동 체크 (query가 있고 queryEmbeddingForReanchor가 생성된 경우)
-        // 기본적으로 활성화되어 있으며, options에 autoMoveEnabled: false를 전달하여 비활성화 가능
-        if (queryEmbeddingForReanchor && options?.autoMoveEnabled !== false) {
-            try {
-                await this.checkAndAutoReanchor(agentId, slot, queryEmbeddingForReanchor, true);
-            }
             catch (error) {
                 // 자동 앵커 이동 실패는 검색 결과에 영향을 주지 않음
-                console.debug('⚠️ 자동 앵커 이동 체크 실패 (무시됨):', error);
+                logger.debug('Auto anchor move check failed (ignored)', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
             }
         }
-        const queryTime = Date.now() - startTime;
-        return {
-            items: finalResults,
-            total_count: totalCount,
-            local_results_count: localCount,
-            fallback_used: fallbackUsed,
-            query_time: queryTime,
-            anchor_info: {
-                agent_id: agentId,
-                slot: slot,
-                memory_id: anchor.memory_id
-            }
-        };
+        return searchResult;
     }
     /**
      * 앵커 메모리의 임베딩 조회
-     * @param memoryId - 메모리 ID
-     * @returns 임베딩 벡터 및 제공자 정보, 없으면 null
-     * @throws {MemoryNotFoundError} 메모리가 삭제된 경우
      */
     async getAnchorEmbedding(memoryId) {
-        if (!this.db) {
-            throw new Error('Database is not set.');
-        }
-        try {
-            // Edge Case: 메모리 존재 확인 (메모리 삭제 체크)
-            const memoryExists = this.db.prepare(`
-        SELECT id FROM memory_item WHERE id = ?
-      `).get(memoryId);
-            if (!memoryExists) {
-                // 메모리가 삭제된 경우
-                console.warn(`⚠️ Memory '${memoryId}' not found (may have been deleted)`);
-                return null;
-            }
-            const embeddingRecord = this.db.prepare(`
-        SELECT 
-          embedding,
-          embedding_provider,
-          dimensions,
-          dim
-        FROM memory_embedding
-        WHERE memory_id = ?
-        ORDER BY created_at DESC
-        LIMIT 1
-      `).get(memoryId);
-            if (!embeddingRecord || !embeddingRecord.embedding) {
-                // Edge Case: 임베딩 없음 (메모리는 존재하지만 임베딩이 없음)
-                return null;
-            }
-            // JSON 문자열로 저장된 임베딩을 배열로 파싱
-            let embeddingVector;
-            try {
-                embeddingVector = typeof embeddingRecord.embedding === 'string'
-                    ? JSON.parse(embeddingRecord.embedding)
-                    : embeddingRecord.embedding;
-                if (!Array.isArray(embeddingVector) || embeddingVector.length === 0) {
-                    // Edge Case: 유효하지 않은 임베딩
-                    console.warn(`⚠️ Invalid embedding for memory '${memoryId}' (empty or not an array)`);
-                    return null;
-                }
-            }
-            catch (error) {
-                // Edge Case: 임베딩 파싱 실패
-                console.error(`❌ 임베딩 파싱 실패 (${memoryId}):`, error);
-                return null;
-            }
-            const provider = embeddingRecord.embedding_provider || 'tfidf';
-            return {
-                embedding: embeddingVector,
-                provider: provider
-            };
-        }
-        catch (error) {
-            // Edge Case: 데이터베이스 오류
-            console.error(`❌ 임베딩 조회 실패 (${memoryId}):`, error);
-            return null;
-        }
-    }
-    /**
-     * 1-hop 검색: 앵커와 직접적으로 유사한 메모리 검색
-     * @param anchorEmbedding - 앵커 메모리의 임베딩 벡터
-     * @param provider - 임베딩 제공자
-     * @param anchorMemoryId - 앵커 메모리 ID (제외할 메모리)
-     * @param threshold - 유사도 임계값
-     * @param limit - 최대 결과 수
-     * @returns 검색 결과
-     */
-    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) {
-            console.error(`❌ 1-hop 검색 실패:`, error);
-            throw new Error(`Failed to perform 1-hop search: ${error instanceof Error ? error.message : 'Unknown error'}`);
-        }
-    }
-    /**
-     * N-hop 검색: 앵커를 기준으로 최대 N-hop까지 확장 검색
-     * @param anchorEmbedding - 앵커 메모리의 임베딩 벡터
-     * @param provider - 임베딩 제공자
-     * @param anchorMemoryId - 앵커 메모리 ID (제외할 메모리)
-     * @param threshold - 유사도 임계값
-     * @param maxHops - 최대 hop 수
-     * @param limit - 최대 결과 수 (전체 hop 합계)
-     * @returns 검색 결과 (hop_distance 포함)
-     */
-    async searchNHop(anchorEmbedding, provider, anchorMemoryId, threshold, maxHops, limit) {
-        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를 활용한 직접 연결된 메모리 조회 (최적화)
-                    const linkedMemories = 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);
-                    // 디버깅: 벡터 검색 결과 로깅
-                    if (hop === 1 && currentMemory.memory_id === anchorMemoryId) {
-                        console.log(`🔍 [Debug] 벡터 검색 결과 (${hop}-hop, 앵커: ${anchorMemoryId}):`, {
-                            totalResults: vectorSearchResults.length,
-                            top5Similarities: vectorSearchResults.slice(0, 5).map(r => ({
-                                memory_id: r.memory_id,
-                                similarity: r.similarity.toFixed(4)
-                            })),
-                            threshold,
-                            provider
-                        });
-                    }
-                    // memory_link 결과와 벡터 검색 결과를 병합
-                    // 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
-                            });
-                        }
-                    }
-                    // 벡터 검색 결과 추가 (memory_link에 없는 경우만)
-                    // 임계값을 낮춰서 더 많은 결과를 포함 (나중에 effectiveThreshold로 재필터링)
-                    const relaxedThreshold = threshold * 0.5; // 임계값을 50%로 완화하여 후보 확보
-                    for (const result of vectorSearchResults) {
-                        if (!allCandidates.has(result.memory_id) && !discoveredMemoryIds.has(result.memory_id)) {
-                            // 완화된 임계값으로 후보 추가 (나중에 effectiveThreshold로 재필터링)
-                            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;
-                        }
-                        // 유사도 임계값 이상만 반환 (memory_link는 임계값 완화 가능)
-                        const effectiveThreshold = candidate.isLinked
-                            ? threshold * 0.8 // memory_link 연결은 임계값 20% 완화
-                            : 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
-                        });
-                        // 다음 hop을 위한 임베딩 조회 (다음 hop이 있을 경우)
-                        // Edge Case: 중간 hop의 메모리가 삭제되거나 임베딩이 없는 경우 무시
-                        if (hop < maxHops) {
-                            try {
-                                const nextEmbedding = await this.getAnchorEmbedding(candidate.memory_id);
-                                if (nextEmbedding && nextEmbedding.embedding) {
-                                    nextHopMemories.push({
-                                        memory_id: candidate.memory_id,
-                                        embedding: nextEmbedding.embedding
-                                    });
-                                }
-                                else {
-                                    // 임베딩이 없으면 다음 hop에서 제외 (경고 없이)
-                                    console.debug(`⚠️ Skipping memory '${candidate.memory_id}' for next hop: no embedding`);
-                                }
-                            }
-                            catch (error) {
-                                // 메모리 삭제 또는 임베딩 조회 실패 시 다음 hop에서 제외
-                                console.debug(`⚠️ Skipping memory '${candidate.memory_id}' for next hop: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`❌ ${hop}-hop 검색 실패 (${currentMemory.memory_id}):`, error);
-                    // 개별 메모리 검색 실패는 무시하고 계속 진행
-                    continue;
-                }
-            }
-            // 현재 hop의 결과를 전체 결과에 추가 (hop_distance 설정)
-            for (const result of hopResults) {
-                allResults.push({
-                    ...result,
-                    hop_distance: hop
-                });
-            }
-            // limit에 도달했으면 중단
-            if (allResults.length >= limit) {
-                break;
-            }
-            // 다음 hop을 위한 메모리가 없으면 중단
-            if (nextHopMemories.length === 0) {
-                break;
-            }
-            // 다음 hop을 위한 메모리로 업데이트
-            currentHopMemories = nextHopMemories;
-        }
-        // 랭킹 점수 계산 및 적용 (hop 거리 기반 점수 + 앵커 근처 부스트)
-        const rankedResults = allResults.map(result => {
-            const rankingScore = this.calculateRankingScore(result.similarity, result.hop_distance, result.importance);
-            return {
-                ...result,
-                similarity: rankingScore // 랭킹 점수로 업데이트
-            };
-        });
-        // 랭킹 점수 기준으로 정렬 (높은 점수 우선)
-        rankedResults.sort((a, b) => {
-            // 점수가 같으면 hop 거리가 가까운 것 우선
-            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);
-    }
-    /**
-     * 쿼리 기반 필터링: 앵커 주변 검색 결과 중 쿼리와 관련된 메모리만 필터링
-     * @param query - 검색 쿼리
-     * @param results - 앵커 주변 검색 결과
-     * @param provider - 임베딩 제공자
-     * @returns 필터링된 결과 (쿼리 관련성 점수 포함)
-     */
-    async filterByQuery(query, results, provider) {
-        if (results.length === 0) {
-            return results;
-        }
-        try {
-            // 1. 쿼리 임베딩 생성
-            const queryEmbeddingResult = await this.queryEmbeddingService.generateEmbedding(query);
-            if (!queryEmbeddingResult || !queryEmbeddingResult.embedding) {
-                console.warn('⚠️ 쿼리 임베딩 생성 실패, 필터링 건너뜀');
-                return results;
-            }
-            const queryEmbedding = queryEmbeddingResult.embedding;
-            // 2. 각 결과 메모리의 임베딩 조회 및 쿼리 유사도 계산
-            const resultsWithQuerySimilarity = await Promise.all(results.map(async (result) => {
-                try {
-                    // 메모리 임베딩 조회
-                    const memoryEmbedding = await this.getAnchorEmbedding(result.memory_id);
-                    if (!memoryEmbedding || !memoryEmbedding.embedding) {
-                        // 임베딩이 없으면 쿼리 유사도 0으로 설정
-                        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 {
-                        // 차원이 다르면 텍스트 기반 간단한 매칭 (fallback)
-                        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);
-                    }
-                    // hop 거리 기반 랭킹 점수 계산
-                    const baseRankingScore = this.calculateRankingScore(result.similarity, result.hop_distance, result.importance);
-                    // 결합 유사도: 랭킹 점수(60%) + 쿼리 유사도(40%)
-                    const combinedSimilarity = baseRankingScore * 0.6 + querySim * 0.4;
-                    return {
-                        ...result,
-                        query_similarity: querySim,
-                        combined_similarity: combinedSimilarity
-                    };
-                }
-                catch (error) {
-                    console.error(`❌ 쿼리 필터링 실패 (${result.memory_id}):`, error);
-                    // 에러 발생 시 원본 similarity 사용
-                    return {
-                        ...result,
-                        query_similarity: 0,
-                        combined_similarity: result.similarity * 0.5
-                    };
-                }
-            }));
-            // 3. 쿼리 유사도 임계값 적용 (0.3 이상만 유지)
-            const queryThreshold = 0.3;
-            const filtered = resultsWithQuerySimilarity.filter(r => r.query_similarity >= queryThreshold || r.combined_similarity >= 0.5);
-            // 4. 결합 유사도 기준으로 재정렬
-            filtered.sort((a, b) => {
-                // 결합 유사도가 같으면 hop 거리가 가까운 것 우선
-                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;
-            });
-            // 5. 원본 similarity를 combined_similarity로 업데이트하여 반환
-            return filtered.map(r => ({
-                ...r,
-                similarity: r.combined_similarity
-            }));
-        }
-        catch (error) {
-            console.error('❌ 쿼리 기반 필터링 실패:', error);
-            // 에러 발생 시 원본 결과 반환
-            return results;
-        }
-    }
-    /**
-     * 검색 결과 랭킹 점수 계산 (hop 거리 기반 점수 + 앵커 근처 부스트)
-     * @param similarity - 벡터 유사도 (0-1)
-     * @param hopDistance - hop 거리 (1부터 시작)
-     * @param importance - 메모리 중요도 (0-1)
-     * @returns 랭킹 점수 (0-1)
-     */
-    calculateRankingScore(similarity, hopDistance, importance = 0.5) {
-        // 1. Hop 거리 기반 점수 감쇠 (거리가 멀수록 점수 감소)
-        // hop_distance=1: 1.0, hop_distance=2: 0.7, hop_distance=3: 0.5
-        const hopDecayFactor = 1.0 / (1.0 + (hopDistance - 1) * 0.3);
-        // 2. 앵커 근처 부스트 (1-hop은 추가 부스트)
-        const anchorProximityBoost = hopDistance === 1 ? 1.2 : 1.0; // 1-hop은 20% 부스트
-        // 3. 중요도 가중치 (0.1 가중치)
-        const importanceWeight = 0.1;
-        const importanceBoost = 1.0 + (importance - 0.5) * importanceWeight;
-        // 4. 최종 랭킹 점수 계산
-        // 기본 공식: similarity * hop_decay * proximity_boost * importance_boost
-        // 점수가 1.0을 초과하지 않도록 클램프
-        const rankingScore = Math.min(1.0, similarity * hopDecayFactor * anchorProximityBoost * importanceBoost);
-        return rankingScore;
-    }
-    /**
-     * 코사인 유사도 계산
-     * @param a - 벡터 A
-     * @param b - 벡터 B
-     * @returns 코사인 유사도 (0-1)
-     */
-    cosineSimilarity(a, b) {
-        if (a.length !== b.length) {
-            throw new Error('벡터 차원이 일치하지 않습니다');
-        }
-        let dotProduct = 0;
-        let normA = 0;
-        let normB = 0;
-        for (let i = 0; i < a.length; i++) {
-            const aVal = a[i] ?? 0;
-            const bVal = b[i] ?? 0;
-            dotProduct += aVal * bVal;
-            normA += aVal * aVal;
-            normB += bVal * bVal;
-        }
-        const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
-        return magnitude === 0 ? 0 : dotProduct / magnitude;
-    }
-    /**
-     * memory_link 테이블을 활용한 직접 연결된 메모리 조회
-     * @param memoryId - 메모리 ID
-     * @returns 연결된 메모리 목록 (임베딩 정보 포함)
-     */
-    async getLinkedMemories(memoryId) {
-        if (!this.db) {
-            return [];
-        }
-        try {
-            // 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 연결은 높은 유사도로 간주
-                importance: record.importance,
-                created_at: record.created_at,
-                tags: record.tags ? (typeof record.tags === 'string' ? JSON.parse(record.tags) : record.tags) : undefined
-            }));
-        }
-        catch (error) {
-            console.error(`❌ memory_link 조회 실패 (${memoryId}):`, error);
-            return [];
-        }
-    }
-    /**
-     * 전역 검색으로 Fallback
-     * @param query - 검색 쿼리
-     * @param options - 검색 옵션
-     * @param startTime - 시작 시간
-     * @returns 검색 결과
-     */
-    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, // finalScore를 similarity로 사용
-                importance: item.importance,
-                created_at: item.created_at,
-                tags: item.tags,
-                // fallback 결과는 hop_distance가 없음 (전역 검색이므로)
-                hop_distance: undefined
-            }));
-            const queryTime = startTime ? Date.now() - startTime : Date.now() - fallbackStartTime;
-            return {
-                items: convertedItems,
-                total_count: convertedItems.length,
-                local_results_count: 0, // 전역 검색이므로 local 결과는 0
-                fallback_used: true,
-                query_time: queryTime
-            };
-        }
-        catch (error) {
-            console.error('❌ 전역 검색 Fallback 실패:', error);
-            const queryTime = startTime ? Date.now() - startTime : 0;
-            // 에러 발생 시 빈 결과 반환
-            return {
-                items: [],
-                total_count: 0,
-                local_results_count: 0,
-                fallback_used: true,
-                query_time: queryTime
-            };
-        }
+        return this.cacheService.getAnchorEmbedding(memoryId);
     }
     /**
      * 서버 재시작 시 DB에서 캐시 복원
-     * @param db - 데이터베이스 인스턴스
      */
     async restoreCacheFromDB(db) {
-        if (!db) {
-            throw new Error('Database instance is required');
-        }
-        try {
-            // anchor 테이블 존재 여부 확인
-            const tableExists = db.prepare(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name='anchor'
-      `).get();
-            if (!tableExists) {
-                // 테이블이 없으면 빈 캐시로 시작 (마이그레이션이 아직 실행되지 않았을 수 있음)
-                this.cache.clear();
-                console.log('⚠️ Anchor table does not exist yet, starting with empty cache');
-                return;
-            }
-            const anchors = db.prepare(`
-        SELECT agent_id, slot, memory_id
-        FROM anchor
-        ORDER BY agent_id, slot
-      `).all();
-            // 캐시 초기화
-            this.cache.clear();
-            // DB 데이터로 캐시 복원
-            for (const anchor of anchors) {
-                const agentId = anchor.agent_id;
-                const slot = anchor.slot;
-                const memoryId = anchor.memory_id;
-                if (!this.cache.has(agentId)) {
-                    this.cache.set(agentId, { A: null, B: null, C: null });
-                }
-                const agentCache = this.cache.get(agentId);
-                agentCache[slot] = memoryId;
-            }
-            console.log(`✅ Anchor cache restored: ${this.cache.size} agents`);
-        }
-        catch (error) {
-            // 에러 발생 시 빈 캐시로 시작 (테이블이 없거나 다른 문제)
-            this.cache.clear();
-            console.warn('⚠️ Failed to restore anchor cache from DB, starting with empty cache:', error instanceof Error ? error.message : String(error));
-        }
-    }
-    /**
-     * 캐시 업데이트 헬퍼 메서드
-     * @param agentId - 에이전트 ID
-     * @param slot - 슬롯
-     * @param memoryId - 메모리 ID (null이면 제거)
-     */
-    updateCache(agentId, slot, memoryId) {
-        if (!this.cache.has(agentId)) {
-            this.cache.set(agentId, { A: null, B: null, C: null });
-        }
-        const agentCache = this.cache.get(agentId);
-        agentCache[slot] = memoryId;
+        return this.cacheService.restoreCacheFromDB(db);
     }
     /**
      * 슬롯별 설정 조회
-     * @param slot - 슬롯
-     * @returns 슬롯 설정 (hop_limit, vector_threshold)
      */
     getSlotConfig(slot) {
-        return this.slotConfig[slot];
+        return this.newAnchorManager.getSlotConfig(slot);
     }
     /**
-     * 자동 앵커 이동 점수 계산
-     * 사용 빈도와 의미적 거리를 종합한 점수
-     * @param memoryId - 메모리 ID
-     * @param queryEmbedding - 검색 쿼리 임베딩 (선택적)
-     * @param anchorEmbedding - 현재 앵커 임베딩 (선택적)
-     * @returns 앵커 이동 점수 (0-1)
+     * 자동 앵커 이동 실행
      */
-    async calculateReanchorScore(memoryId, queryEmbedding, anchorEmbedding) {
-        if (!this.db) {
-            return 0;
-        }
-        try {
-            // 1. 사용 빈도 점수 계산 (view_count, cite_count, last_accessed 기반)
-            const memory = this.db.prepare(`
-        SELECT 
-          view_count,
-          cite_count,
-          edit_count,
-          last_accessed,
-          created_at,
-          importance
-        FROM memory_item
-        WHERE id = ?
-      `).get(memoryId);
-            if (!memory) {
-                return 0;
-            }
-            // 사용 빈도 점수 (로그 스케일)
-            const usageScore = Math.min(1.0, (Math.log(1 + memory.view_count) +
-                2 * Math.log(1 + memory.cite_count) +
-                0.5 * Math.log(1 + memory.edit_count)) / 10 // 정규화
-            );
-            // 최근성 점수 (last_accessed 기반, 최근일수록 높음)
-            let recencyScore = 0.5; // 기본값
-            if (memory.last_accessed) {
-                const lastAccessed = new Date(memory.last_accessed);
-                const now = new Date();
-                const daysSinceAccess = (now.getTime() - lastAccessed.getTime()) / (1000 * 60 * 60 * 24);
-                // 7일 이내면 높은 점수, 그 이후로 감소
-                recencyScore = Math.max(0, 1.0 - daysSinceAccess / 30);
-            }
-            // 중요도 점수
-            const importanceScore = memory.importance || 0.5;
-            // 2. 의미적 거리 점수 계산 (query와의 유사도)
-            let semanticScore = 0.5; // 기본값
-            if (queryEmbedding) {
-                const memoryEmbedding = await this.getAnchorEmbedding(memoryId);
-                if (memoryEmbedding && memoryEmbedding.embedding) {
-                    const similarity = this.cosineSimilarity(queryEmbedding, memoryEmbedding.embedding);
-                    semanticScore = similarity;
-                }
-            }
-            // 3. 현재 앵커와의 비교 (현재 앵커보다 더 나은지)
-            let anchorComparisonScore = 0.5; // 기본값
-            if (anchorEmbedding) {
-                const memoryEmbedding = await this.getAnchorEmbedding(memoryId);
-                if (memoryEmbedding && memoryEmbedding.embedding) {
-                    const similarity = this.cosineSimilarity(anchorEmbedding, memoryEmbedding.embedding);
-                    // 현재 앵커와 유사하면 낮은 점수, 다르면 높은 점수 (다양성)
-                    anchorComparisonScore = 1.0 - similarity;
-                }
-            }
-            // 4. 종합 점수 계산 (가중 평균)
-            // 사용 빈도(30%) + 최근성(20%) + 중요도(20%) + 의미적 거리(20%) + 앵커 비교(10%)
-            const finalScore = usageScore * 0.3 +
-                recencyScore * 0.2 +
-                importanceScore * 0.2 +
-                semanticScore * 0.2 +
-                anchorComparisonScore * 0.1;
-            return Math.min(1.0, Math.max(0.0, finalScore));
-        }
-        catch (error) {
-            console.error(`❌ 앵커 이동 점수 계산 실패 (${memoryId}):`, error);
-            return 0;
-        }
+    async autoReanchor(agentId, slot, queryEmbedding, threshold = 0.7, strategy = 'gradual') {
+        return this.searchService.autoReanchor(agentId, slot, this.newAnchorManager, queryEmbedding, threshold, strategy);
     }
     /**
      * 앵커 주변 메모리 사용 패턴 분석
-     * @param agentId - 에이전트 ID
-     * @param slot - 슬롯
-     * @param queryEmbedding - 검색 쿼리 임베딩 (선택적)
-     * @returns 더 적합한 앵커 후보 목록 (점수 내림차순)
      */
     async analyzeAnchorUsage(agentId, slot, queryEmbedding) {
         if (!this.db) {
@@ -1111,160 +238,17 @@ export class AnchorManager {
         if (!anchor || Array.isArray(anchor) || !anchor.memory_id) {
             return [];
         }
-        try {
-            // 현재 앵커 임베딩 조회
-            const anchorEmbedding = await this.getAnchorEmbedding(anchor.memory_id);
-            if (!anchorEmbedding) {
-                return [];
-            }
-            // 앵커 주변 메모리 검색 (1-hop)
-            const slotConfig = this.getSlotConfig(slot);
-            const nearbyMemories = await this.searchNHop(anchorEmbedding.embedding, anchorEmbedding.provider, anchor.memory_id, slotConfig.vector_threshold * 0.8, // 더 넓은 범위
-            slotConfig.hop_limit, 20 // 더 많은 후보
-            );
-            // 각 메모리에 대해 앵커 이동 점수 계산
-            const candidates = [];
-            for (const memory of nearbyMemories) {
-                const score = await this.calculateReanchorScore(memory.memory_id, queryEmbedding, anchorEmbedding.embedding);
-                if (score > 0.5) { // 최소 점수 이상만 후보로
-                    const reason = this.generateReanchorReason(memory, score);
-                    candidates.push({
-                        memory_id: memory.memory_id,
-                        score,
-                        reason
-                    });
-                }
-            }
-            // 점수 내림차순 정렬
-            candidates.sort((a, b) => b.score - a.score);
-            return candidates;
-        }
-        catch (error) {
-            console.error(`❌ 앵커 사용 패턴 분석 실패 (${agentId}/${slot}):`, error);
+        const anchorEmbedding = await this.cacheService.getAnchorEmbedding(anchor.memory_id);
+        if (!anchorEmbedding) {
             return [];
         }
+        return this.searchService.analyzeAnchorUsage(agentId, slot, anchor.memory_id, anchorEmbedding, queryEmbedding);
     }
     /**
-     * 앵커 이동 이유 생성
-     */
-    generateReanchorReason(memory, score) {
-        const reasons = [];
-        if (score > 0.7) {
-            reasons.push('높은 사용 빈도');
-        }
-        if (memory.similarity && memory.similarity > 0.8) {
-            reasons.push('쿼리와 높은 유사도');
-        }
-        if (memory.hop_distance === 1) {
-            reasons.push('앵커와 직접 연결');
-        }
-        return reasons.length > 0 ? reasons.join(', ') : '종합 점수 우수';
-    }
-    /**
-     * 자동 앵커 이동 실행
-     * @param agentId - 에이전트 ID
-     * @param slot - 슬롯
-     * @param queryEmbedding - 검색 쿼리 임베딩 (선택적)
-     * @param threshold - 이동 임계값 (기본값: 0.7)
-     * @param strategy - 이동 전략 ('gradual' | 'immediate', 기본값: 'gradual')
-     * @returns 이동 결과 (이동 여부, 새 앵커 정보)
-     */
-    async autoReanchor(agentId, slot, queryEmbedding, threshold = 0.7, strategy = 'gradual') {
-        if (!this.db) {
-            throw new Error('Database is not set.');
-        }
-        try {
-            // 현재 앵커 조회
-            const currentAnchor = await this.getAnchor(agentId, slot);
-            if (!currentAnchor || Array.isArray(currentAnchor) || !currentAnchor.memory_id) {
-                return {
-                    moved: false,
-                    old_anchor: null,
-                    new_anchor: null,
-                    score: 0,
-                    reason: '앵커가 설정되지 않았습니다'
-                };
-            }
-            // 더 적합한 앵커 후보 찾기
-            const candidates = await this.analyzeAnchorUsage(agentId, slot, queryEmbedding);
-            if (candidates.length === 0 || !candidates[0] || candidates[0].score < threshold) {
-                return {
-                    moved: false,
-                    old_anchor: currentAnchor.memory_id,
-                    new_anchor: null,
-                    score: candidates[0]?.score || 0,
-                    reason: `임계값(${threshold}) 미만 또는 후보 없음`
-                };
-            }
-            const bestCandidate = candidates[0];
-            if (!bestCandidate) {
-                return {
-                    moved: false,
-                    old_anchor: currentAnchor.memory_id,
-                    new_anchor: null,
-                    score: 0,
-                    reason: '후보 없음'
-                };
-            }
-            // 이동 전략에 따라 처리
-            if (strategy === 'gradual') {
-                // 점진적 이동: 기존 앵커를 B나 C로 이동하고 새로운 메모리를 A에 설정
-                if (slot === 'A') {
-                    // A -> B로 이동
-                    const bAnchor = await this.getAnchor(agentId, 'B');
-                    if (bAnchor && !Array.isArray(bAnchor) && bAnchor.memory_id) {
-                        // B -> C로 이동 (인자 순서: agentId, memoryId, slot)
-                        await this.setAnchor(agentId, bAnchor.memory_id, 'C');
-                    }
-                    // 현재 A -> B로 이동
-                    await this.setAnchor(agentId, currentAnchor.memory_id, 'B');
-                }
-                else if (slot === 'B') {
-                    // B -> C로 이동
-                    await this.setAnchor(agentId, currentAnchor.memory_id, 'C');
-                }
-                // 새로운 메모리를 현재 슬롯에 설정
-                await this.setAnchor(agentId, bestCandidate.memory_id, slot);
-            }
-            else {
-                // 급격한 이동: 현재 앵커를 완전히 교체
-                await this.setAnchor(agentId, bestCandidate.memory_id, slot);
-            }
-            console.log(`🔄 자동 앵커 이동 완료: ${agentId}/${slot} ` +
-                `${currentAnchor.memory_id} -> ${bestCandidate.memory_id} ` +
-                `(점수: ${bestCandidate.score.toFixed(3)}, 이유: ${bestCandidate.reason})`);
-            return {
-                moved: true,
-                old_anchor: currentAnchor.memory_id,
-                new_anchor: bestCandidate.memory_id,
-                score: bestCandidate.score,
-                reason: bestCandidate.reason
-            };
-        }
-        catch (error) {
-            console.error(`❌ 자동 앵커 이동 실패 (${agentId}/${slot}):`, error);
-            throw error;
-        }
-    }
-    /**
-     * 검색 후 자동 앵커 이동 체크 (선택적)
-     * @param agentId - 에이전트 ID
-     * @param slot - 슬롯
-     * @param queryEmbedding - 검색 쿼리 임베딩
-     * @param autoMoveEnabled - 자동 이동 활성화 여부 (기본값: false)
-     * @returns 이동 결과
+     * 검색 후 자동 앵커 이동 체크
      */
     async checkAndAutoReanchor(agentId, slot, queryEmbedding, autoMoveEnabled = false) {
-        if (!autoMoveEnabled) {
-            return null;
-        }
-        try {
-            return await this.autoReanchor(agentId, slot, queryEmbedding, 0.7, 'gradual');
-        }
-        catch (error) {
-            console.error(`❌ 자동 앵커 이동 체크 실패:`, error);
-            return null;
-        }
+        return this.searchService.checkAndAutoReanchor(agentId, slot, this.newAnchorManager, queryEmbedding, autoMoveEnabled);
     }
 }
 //# sourceMappingURL=anchor-manager.js.map