memento-mcp-server 1.19.3-c → 1.19.3-e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memento-mcp-server",
-  "version": "1.19.3-c",
+  "version": "1.19.3-e",
   "description": "AI Agent 기억 보조 MCP 서버 - 사람의 기억 구조를 모사한 스토리지+검색+요약+망각 메커니즘",
   "type": "module",
   "workspaces": [

package/packages/memento-server/dist/server/index.js

@@ -37,6 +37,10 @@ let server;
 let db = null;
 // core에서 반환된 서비스 (ToolContext 생성 시 사용)
 let serverServices = null;
+/** Cursor 등 클라이언트가 7초 내에 Initialize 응답을 받도록, 무거운 초기화는 transport 연결 후 백그라운드에서 수행 */
+let initPromise;
+let resolveInit;
+let rejectInit;
 // MCP 서버에서는 모든 로그 출력을 완전히 차단
 // 모든 console 메서드를 빈 함수로 교체
 // MCP 프로토콜 스펙: stdio 전송 시 stdout에는 오직 JSON-RPC 메시지만 출력되어야 함
@@ -145,28 +149,26 @@ async function checkInitialDatabaseStatus() {
         mcpLogger.logServer('warn', '초기 데이터베이스 상태 확인 실패', { error: error instanceof Error ? error.message : String(error) });
     }
 }
-// MCP 서버 초기화
-async function initializeServer() {
+/**
+ * 무거운 초기화(DB·서비스·툴 등). transport 연결 후 백그라운드에서 실행하며,
+ * 완료 시 resolveInit()을 호출해 도구/리소스 요청이 동작하도록 함.
+ */
+async function runHeavyInit() {
     try {
         mcpLogger.logServer('info', `Memento MCP Server v${packageJson.version}`);
-        mcpLogger.logServer('info', 'MCP 서버 초기화 시작...');
-        // 설정 검증
+        mcpLogger.logServer('info', 'MCP 서버 초기화(백그라운드) 시작...');
         validateConfig();
         mcpLogger.logServer('info', '설정 검증 완료');
-        // @memento/core로 DB·서비스 초기화
         const core = await createMementoCore({
             dbPath: process.env.DB_PATH ?? mementoConfig.dbPath
         });
         db = core.db;
-        const services = core.services;
+        serverServices = core.services;
         mcpLogger.logServer('info', '데이터베이스·서비스 초기화 완료');
-        // 초기 데이터베이스 상태 확인 (주기적 모니터링은 DatabaseLockMonitor가 담당)
         await checkInitialDatabaseStatus();
         mcpLogger.logServer('info', '초기 데이터베이스 상태 확인 완료');
-        serverServices = services;
-        // 배치 스케줄러는 core bootstrap에서 이미 시작됨 (services.batchScheduler)
+        const services = serverServices;
         mcpLogger.logServer('info', '서비스 초기화 완료');
-        // 배치 스케줄러 상태 확인
         const batchScheduler = services.batchScheduler;
         const status = batchScheduler ? batchScheduler.getStatus() : { isRunning: false, activeJobs: 0, uptime: 0 };
         mcpLogger.logServer('info', `배치 스케줄러 상태: ${JSON.stringify({
@@ -174,7 +176,6 @@ async function initializeServer() {
             activeJobs: status.activeJobs,
             uptime: status.uptime
         }, null, 2)}`);
-        // 임베딩 프로바이더 정보 표시
         const providerInfo = {
             provider: mementoConfig.embeddingProvider.toUpperCase()
         };
@@ -192,274 +193,255 @@ async function initializeServer() {
         }
         mcpLogger.logServer('info', '임베딩 프로바이더 정보', providerInfo);
         mcpLogger.logServer('info', '검색 엔진 초기화 완료');
-        // MCP 서버 생성
-        // MCP 스펙 준수: logging capability 선언 (MCP Spec 2024-11-05)
-        // 참조: https://spec.modelcontextprotocol.io/specification/server/#logging
-        // instructions: InitializeResult에 포함되어 클라이언트(Cursor 등)가 AI에게 Memento 사용법을 안내하는 serverUseInstructions로 활용됨
-        server = new Server({
-            name: mementoConfig.serverName,
-            version: mementoConfig.serverVersion,
-        }, {
-            capabilities: {
-                tools: {},
-                resources: {},
-                prompts: {},
-                logging: {} // MCP 스펙: logging capability 선언 필수
-            },
-            instructions: MEMENTO_SERVER_INSTRUCTIONS
-        });
-        // MCP 로거에 Server 인스턴스 설정
-        mcpLogger.setServer(server);
-        mcpLogger.logServer('info', 'MCP 서버 생성 완료');
-        // 주의: isTransportConnected 플래그는 server.connect() 호출 직전에 설정됨
-        // initializeServer()에서는 설정하지 않음
-        // 도구 레지스트리 가져오기
+        resolveInit();
+        mcpLogger.logServer('info', 'MCP 서버 초기화(백그라운드) 완료');
+        mcpLogger.logServer('info', 'Memento MCP Server가 시작되었습니다!');
+    }
+    catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        rejectInit(err);
+        mcpLogger.logServer('error', `서버 초기화 실패: ${err.message}`, { error: err.message, stack: err.stack });
+        process.stderr.write(`\n[ERROR] MCP Server Initialization Failed (server stays up; tools will return this error)\n`);
+        process.stderr.write(`Error: ${err.message}\n`);
+        if (err.stack)
+            process.stderr.write(`Stack:\n${err.stack}\n`);
+        process.stderr.write(`\n`);
+        // Do NOT process.exit(1): client would see "Connection closed" during initializing.
+        // Keep server alive so the client gets Initialize response; tool calls will fail with this error.
+    }
+}
+/** MCP 핸들러 등록. 각 핸들러는 await initPromise 후 실제 동작 수행(7초 내 Initialize 응답을 위해) */
+function registerHandlers() {
+    // Tools 등록
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        await initPromise;
+        await mcpLogger.logMCPProtocol('debug', '도구 목록 요청 처리');
         const toolRegistry = getToolRegistry();
-        // Tools 등록
-        server.setRequestHandler(ListToolsRequestSchema, async () => {
-            await mcpLogger.logMCPProtocol('debug', '도구 목록 요청 처리');
-            const tools = toolRegistry.getAll();
-            await mcpLogger.logMCPProtocol('debug', `등록된 도구 개수: ${tools.length}`, { count: tools.length });
-            return {
-                tools: tools.map(tool => ({
-                    name: tool.name,
-                    description: tool.description,
-                    inputSchema: tool.inputSchema
-                }))
-            };
-        });
-        // Resources 목록 핸들러
-        server.setRequestHandler(ListResourcesRequestSchema, async () => {
-            await mcpLogger.logMCPProtocol('debug', '리소스 목록 요청 처리');
-            if (!db) {
-                throw new Error('Database not initialized');
-            }
-            // 모든 메모리 ID 조회
-            const memories = await DatabaseUtils.all(db, 'SELECT id FROM memory_item ORDER BY created_at DESC LIMIT 1000');
-            await mcpLogger.logMCPProtocol('debug', `리소스 개수: ${memories.length}`, { count: memories.length });
-            return {
-                resources: memories.map((memory) => ({
-                    uri: `memory://${memory.id}`,
-                    name: `Memory ${memory.id}`,
-                    description: `Memory item with ID: ${memory.id}`,
-                    mimeType: 'application/json'
-                }))
-            };
-        });
-        // Prompts 목록 핸들러 (listOfferingsForUI 등 클라이언트 호출 시 Method not found 방지)
-        server.setRequestHandler(ListPromptsRequestSchema, async () => {
-            await mcpLogger.logMCPProtocol('debug', '프롬프트 목록 요청 처리');
-            return {
-                prompts: [
-                    {
-                        name: 'memory_injection',
-                        description: '관련 기억을 요약하여 프롬프트에 주입',
-                        arguments: [
-                            { name: 'query', description: '검색할 쿼리', required: true },
-                            { name: 'token_budget', description: '토큰 예산 (기본값: 1000)', required: false },
-                            { name: 'max_memories', description: '최대 기억 개수 (기본값: 5)', required: false }
-                        ]
-                    }
-                ]
-            };
-        });
-        // Prompt 조회 핸들러
-        server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-            const { name } = request.params;
-            await mcpLogger.logMCPProtocol('debug', `프롬프트 조회 요청: ${name}`, { name });
-            if (name === 'memory_injection') {
-                return {
+        const tools = toolRegistry.getAll();
+        await mcpLogger.logMCPProtocol('debug', `등록된 도구 개수: ${tools.length}`, { count: tools.length });
+        return {
+            tools: tools.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema
+            }))
+        };
+    });
+    // Resources 목록 핸들러
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        await initPromise;
+        await mcpLogger.logMCPProtocol('debug', '리소스 목록 요청 처리');
+        if (!db) {
+            throw new Error('Database not initialized');
+        }
+        // 모든 메모리 ID 조회
+        const memories = await DatabaseUtils.all(db, 'SELECT id FROM memory_item ORDER BY created_at DESC LIMIT 1000');
+        await mcpLogger.logMCPProtocol('debug', `리소스 개수: ${memories.length}`, { count: memories.length });
+        return {
+            resources: memories.map((memory) => ({
+                uri: `memory://${memory.id}`,
+                name: `Memory ${memory.id}`,
+                description: `Memory item with ID: ${memory.id}`,
+                mimeType: 'application/json'
+            }))
+        };
+    });
+    // Prompts 목록 핸들러 (listOfferingsForUI 등 클라이언트 호출 시 Method not found 방지)
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        await initPromise;
+        await mcpLogger.logMCPProtocol('debug', '프롬프트 목록 요청 처리');
+        return {
+            prompts: [
+                {
+                    name: 'memory_injection',
                     description: '관련 기억을 요약하여 프롬프트에 주입',
                     arguments: [
                         { name: 'query', description: '검색할 쿼리', required: true },
                         { name: 'token_budget', description: '토큰 예산 (기본값: 1000)', required: false },
                         { name: 'max_memories', description: '최대 기억 개수 (기본값: 5)', required: false }
                     ]
-                };
-            }
-            throw new Error(`Prompt not found: ${name}`);
-        });
-        // Resource 읽기 핸들러
-        server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-            const { uri } = request.params;
-            await mcpLogger.logMCPProtocol('debug', `리소스 읽기 요청: ${uri}`, { uri });
-            // URI 파싱: memory://{id}?include_neighbors=true
-            const uriMatch = uri.match(/^memory:\/\/([^?]+)(\?.*)?$/);
-            if (!uriMatch) {
-                throw new Error(`Invalid resource URI: ${uri}`);
-            }
-            const memoryId = uriMatch[1];
-            if (!memoryId) {
-                throw new Error(`Invalid memory ID in URI: ${uri}`);
-            }
-            const queryString = uriMatch[2] || '';
-            const includeNeighbors = queryString.includes('include_neighbors=true');
-            if (!db) {
-                throw new Error('Database not initialized');
-            }
-            // 메모리 조회
-            const memory = await DatabaseUtils.get(db, 'SELECT id, type, content, importance, privacy_scope, tags, source, created_at, last_accessed, pinned FROM memory_item WHERE id = ?', [memoryId]);
-            if (!memory) {
-                throw new Error(`Memory not found: ${memoryId}`);
-            }
-            // 메모리 데이터 구성
-            const memoryData = {
-                id: memory.id,
-                type: memory.type,
-                content: memory.content,
-                importance: memory.importance,
-                privacy_scope: memory.privacy_scope,
-                tags: memory.tags ? JSON.parse(memory.tags) : [],
-                source: memory.source,
-                created_at: memory.created_at,
-                last_accessed: memory.last_accessed,
-                pinned: memory.pinned === 1
-            };
-            // 이웃 기억 포함 여부 확인
-            if (includeNeighbors) {
-                try {
-                    const vectorSearchEngine = getVectorSearchEngine();
-                    const neighborService = new MemoryNeighborService(vectorSearchEngine, serverServices.embeddingService, db);
-                    const neighborsResult = await neighborService.getNeighbors(memoryId, {
-                        limit: 5,
-                        similarity_threshold: 0.8
-                    });
-                    memoryData.neighbors = neighborsResult.neighbors;
-                    memoryData.neighbors_count = neighborsResult.total_count;
-                    memoryData.neighbors_query_time = neighborsResult.query_time;
-                }
-                catch (error) {
-                    mcpLogger.logServer('warn', `이웃 기억 조회 실패: ${error instanceof Error ? error.message : String(error)}`, { error: error instanceof Error ? error.message : String(error) });
-                    memoryData.neighbors = [];
-                    memoryData.neighbors_count = 0;
                 }
-            }
+            ]
+        };
+    });
+    // Prompt 조회 핸들러
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        await initPromise;
+        const { name } = request.params;
+        await mcpLogger.logMCPProtocol('debug', `프롬프트 조회 요청: ${name}`, { name });
+        if (name === 'memory_injection') {
             return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'application/json',
-                        text: JSON.stringify(memoryData, null, 2)
-                    }
+                description: '관련 기억을 요약하여 프롬프트에 주입',
+                arguments: [
+                    { name: 'query', description: '검색할 쿼리', required: true },
+                    { name: 'token_budget', description: '토큰 예산 (기본값: 1000)', required: false },
+                    { name: 'max_memories', description: '최대 기억 개수 (기본값: 5)', required: false }
                 ]
             };
-        });
-        // Tool 실행 핸들러 - 동시성 제한 적용
-        server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            await mcpLogger.logMCPProtocol('debug', `도구 실행 요청: ${name}`, { toolName: name, args });
-            // 동시성 제한 적용
-            await concurrencyLimiter.acquire();
+        }
+        throw new Error(`Prompt not found: ${name}`);
+    });
+    // Resource 읽기 핸들러
+    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+        await initPromise;
+        const { uri } = request.params;
+        await mcpLogger.logMCPProtocol('debug', `리소스 읽기 요청: ${uri}`, { uri });
+        // URI 파싱: memory://{id}?include_neighbors=true
+        const uriMatch = uri.match(/^memory:\/\/([^?]+)(\?.*)?$/);
+        if (!uriMatch) {
+            throw new Error(`Invalid resource URI: ${uri}`);
+        }
+        const memoryId = uriMatch[1];
+        if (!memoryId) {
+            throw new Error(`Invalid memory ID in URI: ${uri}`);
+        }
+        const queryString = uriMatch[2] || '';
+        const includeNeighbors = queryString.includes('include_neighbors=true');
+        if (!db) {
+            throw new Error('Database not initialized');
+        }
+        // 메모리 조회
+        const memory = await DatabaseUtils.get(db, 'SELECT id, type, content, importance, privacy_scope, tags, source, created_at, last_accessed, pinned FROM memory_item WHERE id = ?', [memoryId]);
+        if (!memory) {
+            throw new Error(`Memory not found: ${memoryId}`);
+        }
+        // 메모리 데이터 구성
+        const memoryData = {
+            id: memory.id,
+            type: memory.type,
+            content: memory.content,
+            importance: memory.importance,
+            privacy_scope: memory.privacy_scope,
+            tags: memory.tags ? JSON.parse(memory.tags) : [],
+            source: memory.source,
+            created_at: memory.created_at,
+            last_accessed: memory.last_accessed,
+            pinned: memory.pinned === 1
+        };
+        // 이웃 기억 포함 여부 확인
+        if (includeNeighbors) {
             try {
-                // Phase 7.8: 공통 에러 핸들러 사용
-                return await withErrorHandling(async () => {
-                    // 부트스트랩에서 초기화된 서비스 객체를 사용하여 ToolContext 생성
-                    if (!serverServices) {
-                        throw new Error('서비스가 초기화되지 않았습니다');
-                    }
-                    if (!db) {
-                        throw new Error('데이터베이스가 초기화되지 않았습니다');
-                    }
-                    // Phase 7.4: 표준 팩토리 함수 사용
-                    const context = createToolContext(db, serverServices);
-                    // 도구 실행
-                    const toolResult = await toolRegistry.execute(name, args, context);
-                    await mcpLogger.logMCPProtocol('debug', `도구 실행 완료: ${name}`, { toolName: name });
-                    // MCP 형식으로 변환
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify(toolResult)
-                            }
-                        ]
-                    };
-                }, {
-                    operation: 'tool_execution',
-                    toolName: name,
-                    requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-                }, {
-                    errorLoggingService: serverServices.errorLoggingService,
-                    severity: ErrorSeverity.HIGH,
-                    category: ErrorCategory.TOOL_EXECUTION,
-                    transformError: (error) => new Error(`Tool execution failed: ${error.message}`)
+                const vectorSearchEngine = getVectorSearchEngine();
+                const neighborService = new MemoryNeighborService(vectorSearchEngine, serverServices.embeddingService, db);
+                const neighborsResult = await neighborService.getNeighbors(memoryId, {
+                    limit: 5,
+                    similarity_threshold: 0.8
                 });
+                memoryData.neighbors = neighborsResult.neighbors;
+                memoryData.neighbors_count = neighborsResult.total_count;
+                memoryData.neighbors_query_time = neighborsResult.query_time;
             }
-            finally {
-                // 동시성 제한 해제
-                concurrencyLimiter.release();
-            }
-        });
-        // logging/setLevel 핸들러 - MCP 스펙 준수
-        // MCP 스펙: logging/setLevel 요청 처리 필수
-        // 참조: https://spec.modelcontextprotocol.io/specification/server/#logging
-        // 
-        // 구현 사항:
-        // - 유효한 로그 레벨 검증 (debug, info, warn, error)
-        // - 환경 변수에 로그 레벨 설정 (MCPLogger가 환경 변수를 읽음)
-        // - 에러 처리: 잘못된 레벨 시 명확한 에러 메시지 반환
-        server.setRequestHandler(SetLevelRequestSchema, async (request) => {
-            const { level } = request.params;
-            await mcpLogger.logMCPProtocol('debug', `로그 레벨 변경 요청: ${level}`, { level });
-            // 로그 레벨 검증 (MCP 스펙: 유효한 레벨만 허용)
-            const validLevels = ['debug', 'info', 'warn', 'error'];
-            if (!validLevels.includes(level)) {
-                throw new Error(`Invalid log level: ${level}. Valid levels are: ${validLevels.join(', ')}`);
+            catch (error) {
+                mcpLogger.logServer('warn', `이웃 기억 조회 실패: ${error instanceof Error ? error.message : String(error)}`, { error: error instanceof Error ? error.message : String(error) });
+                memoryData.neighbors = [];
+                memoryData.neighbors_count = 0;
             }
-            // 환경 변수에 로그 레벨 설정 (MCPLogger의 getCurrentLogLevel()이 환경 변수를 읽음)
-            // MCP 스펙: 로그 레벨 변경은 즉시 적용되어야 함
-            process.env.LOG_LEVEL = level;
-            await mcpLogger.logMCPProtocol('info', `로그 레벨이 ${level}로 변경되었습니다`, { level });
-            return {};
-        });
-        mcpLogger.logServer('info', 'MCP 서버 초기화 완료');
-        // 실시간 성능 모니터링 시작
-        // performanceMonitoringIntegration.startRealTimeMonitoring();
-        mcpLogger.logServer('info', 'Memento MCP Server가 시작되었습니다!');
-        // process.stderr.write('📊 실시간 성능 모니터링이 활성화되었습니다\n');
-    }
-    catch (error) {
-        // 에러 발생 시 상세 정보를 stderr에 출력
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorStack = error instanceof Error ? error.stack : undefined;
-        mcpLogger.logServer('error', `서버 초기화 실패: ${errorMessage}`, {
-            error: errorMessage,
-            stack: errorStack,
-            type: error instanceof Error ? error.constructor.name : typeof error
-        });
-        // stderr에 직접 출력하여 Cursor에서도 확인 가능하도록
-        process.stderr.write(`\n[ERROR] MCP Server Initialization Failed\n`);
-        process.stderr.write(`Error: ${errorMessage}\n`);
-        if (errorStack) {
-            process.stderr.write(`Stack:\n${errorStack}\n`);
         }
-        process.stderr.write(`\n`);
-        process.exit(1);
-    }
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(memoryData, null, 2)
+                }
+            ]
+        };
+    });
+    // Tool 실행 핸들러 - 동시성 제한 적용
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        await initPromise;
+        const { name, arguments: args } = request.params;
+        await mcpLogger.logMCPProtocol('debug', `도구 실행 요청: ${name}`, { toolName: name, args });
+        await concurrencyLimiter.acquire();
+        try {
+            return await withErrorHandling(async () => {
+                if (!serverServices)
+                    throw new Error('서비스가 초기화되지 않았습니다');
+                if (!db)
+                    throw new Error('데이터베이스가 초기화되지 않았습니다');
+                const context = createToolContext(db, serverServices);
+                const toolRegistry = getToolRegistry();
+                const toolResult = await toolRegistry.execute(name, args, context);
+                await mcpLogger.logMCPProtocol('debug', `도구 실행 완료: ${name}`, { toolName: name });
+                // MCP 형식으로 변환
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(toolResult)
+                        }
+                    ]
+                };
+            }, {
+                operation: 'tool_execution',
+                toolName: name,
+                requestId: `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+            }, {
+                errorLoggingService: serverServices.errorLoggingService,
+                severity: ErrorSeverity.HIGH,
+                category: ErrorCategory.TOOL_EXECUTION,
+                transformError: (error) => new Error(`Tool execution failed: ${error.message}`)
+            });
+        }
+        finally {
+            // 동시성 제한 해제
+            concurrencyLimiter.release();
+        }
+    });
+    // logging/setLevel 핸들러 - MCP 스펙 준수
+    // MCP 스펙: logging/setLevel 요청 처리 필수
+    // 참조: https://spec.modelcontextprotocol.io/specification/server/#logging
+    // 
+    // 구현 사항:
+    // - 유효한 로그 레벨 검증 (debug, info, warn, error)
+    // - 환경 변수에 로그 레벨 설정 (MCPLogger가 환경 변수를 읽음)
+    // - 에러 처리: 잘못된 레벨 시 명확한 에러 메시지 반환
+    server.setRequestHandler(SetLevelRequestSchema, async (request) => {
+        await initPromise;
+        const { level } = request.params;
+        await mcpLogger.logMCPProtocol('debug', `로그 레벨 변경 요청: ${level}`, { level });
+        // 로그 레벨 검증 (MCP 스펙: 유효한 레벨만 허용)
+        const validLevels = ['debug', 'info', 'warn', 'error'];
+        if (!validLevels.includes(level)) {
+            throw new Error(`Invalid log level: ${level}. Valid levels are: ${validLevels.join(', ')}`);
+        }
+        // 환경 변수에 로그 레벨 설정 (MCPLogger의 getCurrentLogLevel()이 환경 변수를 읽음)
+        // MCP 스펙: 로그 레벨 변경은 즉시 적용되어야 함
+        process.env.LOG_LEVEL = level;
+        await mcpLogger.logMCPProtocol('info', `로그 레벨이 ${level}로 변경되었습니다`, { level });
+        return {};
+    });
 }
 // 서버 시작
 async function startServer() {
     try {
-        // MCP 프로토콜 준수: transport 연결 전까지는 로그를 억제하여 stdout 오염 방지
-        // initializeServer() 호출 전에 플래그를 설정하여 초기화 중 로그 출력 방지
-        // ServerState를 통해 mcpLogger에서 접근 가능하도록 설정
         serverState.setMcpTransportConnected(false);
-        await initializeServer();
-        mcpLogger.logServer('info', '서버 초기화 완료');
-        // Stdio 전송 계층 사용
-        // MCP SDK의 StdioServerTransport가 stdout을 사용하여 JSON-RPC 메시지 전송
-        // MCP 프로토콜 스펙: stdio 전송 시 stdout에는 오직 JSON-RPC 메시지만 출력되어야 함
+        initPromise = new Promise((resolve, reject) => {
+            resolveInit = resolve;
+            rejectInit = reject;
+        });
+        server = new Server({
+            name: mementoConfig.serverName,
+            version: mementoConfig.serverVersion,
+        }, {
+            capabilities: {
+                tools: {},
+                resources: {},
+                prompts: {},
+                logging: {}
+            },
+            instructions: MEMENTO_SERVER_INSTRUCTIONS
+        });
+        mcpLogger.setServer(server);
+        registerHandlers();
+        // transport를 먼저 연결해 Cursor가 7초 내에 Initialize 응답을 받도록 함
         const transport = new StdioServerTransport();
         await server.connect(transport);
-        // transport 연결 완료 후 로그 출력 허용
         serverState.setMcpTransportConnected(true);
-        // 서버 초기화 완료 플래그 설정
-        // console.error 오버라이드가 MCP Logger를 사용하도록 전환
-        // MCP 스펙 준수 범위: 서버 초기화 완료 후부터 적용
-        // 참조: https://spec.modelcontextprotocol.io/specification/server/#logging
         serverState.setMcpServerInitialized(true);
         mcpLogger.logServer('info', 'MCP 전송 계층 연결 완료');
-        // MCP 클라이언트 연결 대기 중
+        // 무거운 초기화(DB·서비스)는 백그라운드에서 수행
+        void runHeavyInit();
         mcpLogger.logServer('info', 'MCP 클라이언트 연결 대기 중...');
         // 서버가 종료될 때까지 대기
         return new Promise((resolve) => {