memento-mcp-server 0.1.0

package/src/tools/memory-injection-prompt.ts

@@ -0,0 +1,257 @@
+/**
+ * Memory Injection 프롬프트 도구
+ * MCP 프롬프트 인터페이스를 통한 관련 기억 주입
+ */
+
+import { BaseTool } from './base-tool.js';
+import type { ToolContext } from './types.js';
+import { z } from 'zod';
+
+const MemoryInjectionSchema = z.object({
+  query: z.string().describe('검색할 쿼리'),
+  token_budget: z.number().optional().describe('토큰 예산 (기본값: 1000)'),
+  max_memories: z.number().optional().describe('최대 기억 개수 (기본값: 5)'),
+  memory_types: z.array(z.enum(['working', 'episodic', 'semantic', 'procedural'])).optional().describe('포함할 기억 타입들'),
+  importance_threshold: z.number().optional().describe('중요도 임계값 (기본값: 0.5)')
+});
+
+export class MemoryInjectionPrompt extends BaseTool {
+  constructor() {
+    super(
+      'memory_injection',
+      '관련 기억을 요약하여 프롬프트에 주입',
+      {
+        type: 'object',
+        properties: {
+          query: { 
+            type: 'string', 
+            description: '검색할 쿼리' 
+          },
+          token_budget: { 
+            type: 'number', 
+            description: '토큰 예산 (기본값: 1000)',
+            default: 1000
+          },
+          max_memories: { 
+            type: 'number', 
+            description: '최대 기억 개수 (기본값: 5)',
+            default: 5
+          },
+          memory_types: { 
+            type: 'array',
+            items: {
+              type: 'string',
+              enum: ['working', 'episodic', 'semantic', 'procedural']
+            },
+            description: '포함할 기억 타입들',
+            default: ['working', 'episodic', 'semantic', 'procedural']
+          },
+          importance_threshold: { 
+            type: 'number', 
+            description: '중요도 임계값 (기본값: 0.5)',
+            default: 0.5
+          }
+        },
+        required: ['query']
+      }
+    );
+  }
+
+  async handle(params: any, context: ToolContext): Promise<any> {
+    const {
+      query,
+      token_budget = 1000,
+      max_memories = 5,
+      memory_types = ['working', 'episodic', 'semantic', 'procedural'],
+      importance_threshold = 0.5
+    } = MemoryInjectionSchema.parse(params);
+
+    try {
+      console.log(`🧠 Memory Injection 시작: "${query}" (토큰 예산: ${token_budget})`);
+
+      if (!context.db) {
+        throw new Error('데이터베이스가 연결되지 않았습니다');
+      }
+
+      if (!context.services?.hybridSearchEngine) {
+        throw new Error('하이브리드 검색 엔진이 사용할 수 없습니다');
+      }
+
+      // 1. 관련 기억 검색
+      const searchResult = await context.services.hybridSearchEngine.search(context.db, {
+        query,
+        filters: {
+          type: memory_types.length === 4 ? undefined : memory_types as any,
+          importance_min: importance_threshold
+        },
+        limit: max_memories * 2, // 더 많은 후보를 가져와서 요약
+        vectorWeight: 0.7, // 의미적 유사성에 더 중점
+        textWeight: 0.3
+      });
+
+      const memories = searchResult.items;
+      console.log(`🔍 검색된 기억: ${memories.length}개`);
+
+      if (memories.length === 0) {
+        return this.createSuccessResult({
+          message: '관련 기억을 찾을 수 없습니다.',
+          memories_used: 0,
+          token_estimate: 0,
+          query: query
+        });
+      }
+
+      // 2. 기억 요약 및 토큰 예산 관리
+      const summary = await this.summarizeMemories(memories, token_budget, max_memories);
+
+      // 3. 프롬프트 형식으로 포맷팅
+      const formattedPrompt = this.formatMemoryPrompt(summary, query);
+
+      console.log(`✅ Memory Injection 완료: ${summary.length}개 기억, ${this.estimateTokens(formattedPrompt)} 토큰`);
+
+      return this.createSuccessResult({
+        message: formattedPrompt,
+        memories_used: summary.length,
+        token_estimate: this.estimateTokens(formattedPrompt),
+        query: query
+      });
+
+    } catch (error) {
+      console.error('❌ Memory Injection 실패:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 기억들을 요약하여 토큰 예산 내에서 관리
+   */
+  private async summarizeMemories(
+    memories: any[], 
+    tokenBudget: number, 
+    maxMemories: number
+  ): Promise<Array<{id: string, content: string, type: string, importance: number, summary: string}>> {
+    const summaries: Array<{id: string, content: string, type: string, importance: number, summary: string}> = [];
+    let usedTokens = 0;
+    const maxTokensPerMemory = Math.floor(tokenBudget / maxMemories);
+
+    // 중요도와 점수 순으로 정렬
+    const sortedMemories = memories
+      .sort((a, b) => (b.finalScore + b.importance) - (a.finalScore + a.importance))
+      .slice(0, maxMemories);
+
+    for (const memory of sortedMemories) {
+      if (usedTokens >= tokenBudget) break;
+
+      // 기억 내용 요약
+      const summary = this.summarizeMemoryContent(memory.content, maxTokensPerMemory);
+      const summaryTokens = this.estimateTokens(summary);
+
+      if (usedTokens + summaryTokens <= tokenBudget) {
+        summaries.push({
+          id: memory.id,
+          content: memory.content,
+          type: memory.type,
+          importance: memory.importance,
+          summary
+        });
+        usedTokens += summaryTokens;
+      }
+    }
+
+    return summaries;
+  }
+
+  /**
+   * 개별 기억 내용 요약
+   */
+  private summarizeMemoryContent(content: string, maxTokens: number): string {
+    // 간단한 요약 로직 (실제로는 더 정교한 요약 알고리즘 사용 가능)
+    const words = content.split(' ');
+    const maxWords = Math.floor(maxTokens / 1.5); // 대략적인 단어 수 계산
+
+    if (words.length <= maxWords) {
+      return content;
+    }
+
+    // 중요도 기반 요약 (첫 문장 + 마지막 문장 + 중간 핵심 내용)
+    const sentences = content.split(/[.!?]+/).filter(s => s.trim().length > 0);
+    
+    if (sentences.length <= 2) {
+      return words.slice(0, maxWords).join(' ') + '...';
+    }
+
+    const firstSentence = sentences[0]?.trim() || '';
+    const lastSentence = sentences[sentences.length - 1]?.trim() || '';
+    const middleSentences = sentences.slice(1, -1);
+    
+    let summary = firstSentence;
+    let remainingWords = maxWords - firstSentence.split(' ').length;
+
+    if (remainingWords > 0 && middleSentences.length > 0) {
+      const middleText = middleSentences.join('. ');
+      const middleWords = middleText.split(' ');
+      const middleWordsToInclude = Math.min(remainingWords - lastSentence.split(' ').length, middleWords.length);
+      
+      if (middleWordsToInclude > 0) {
+        summary += ' ' + middleWords.slice(0, middleWordsToInclude).join(' ');
+        remainingWords -= middleWordsToInclude;
+      }
+    }
+
+    if (remainingWords > 0) {
+      summary += ' ' + lastSentence;
+    }
+
+    return summary + (summary.length < content.length ? '...' : '');
+  }
+
+  /**
+   * 프롬프트 형식으로 포맷팅
+   */
+  private formatMemoryPrompt(
+    summaries: Array<{id: string, content: string, type: string, importance: number, summary: string}>,
+    query: string
+  ): string {
+    if (summaries.length === 0) {
+      return '관련 기억을 찾을 수 없습니다.';
+    }
+
+    let prompt = `# 관련 기억 (${summaries.length}개)\n\n`;
+    prompt += `**검색 쿼리**: "${query}"\n\n`;
+
+    summaries.forEach((memory, index) => {
+      const typeEmoji = this.getMemoryTypeEmoji(memory.type);
+      const importanceStars = '★'.repeat(Math.ceil(memory.importance * 5));
+      
+      prompt += `## ${index + 1}. ${typeEmoji} ${memory.type.toUpperCase()} 기억\n`;
+      prompt += `**중요도**: ${importanceStars} (${memory.importance.toFixed(2)})\n`;
+      prompt += `**내용**: ${memory.summary}\n\n`;
+    });
+
+    prompt += '---\n';
+    prompt += '*이 기억들은 현재 대화와 관련된 맥락 정보입니다. 참고하여 더 정확하고 관련성 높은 답변을 제공하세요.*';
+
+    return prompt;
+  }
+
+  /**
+   * 기억 타입별 이모지
+   */
+  private getMemoryTypeEmoji(type: string): string {
+    const emojiMap: Record<string, string> = {
+      'working': '🧠',
+      'episodic': '📝',
+      'semantic': '📚',
+      'procedural': '⚙️'
+    };
+    return emojiMap[type] || '💭';
+  }
+
+  /**
+   * 토큰 수 추정 (간단한 추정)
+   */
+  private estimateTokens(text: string): number {
+    // 대략적인 토큰 수 추정 (실제로는 더 정확한 토크나이저 사용 가능)
+    return Math.ceil(text.length / 4);
+  }
+}

package/src/tools/performance-alerts.ts

@@ -0,0 +1,226 @@
+/**
+ * 성능 알림 도구
+ * 성능 알림 조회, 해결, 통계 확인을 위한 MCP 도구
+ */
+
+import { z } from 'zod';
+import type { ToolContext } from './types.js';
+
+export const performanceAlertsTool = {
+  name: 'performance_alerts',
+  description: '성능 알림 정보를 조회하고 관리합니다',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        enum: ['stats', 'list', 'search', 'resolve'],
+        default: 'stats',
+        description: '수행할 작업'
+      },
+      hours: {
+        type: 'number',
+        minimum: 1,
+        maximum: 168,
+        default: 24,
+        description: '조회할 시간 범위 (시간 단위)'
+      },
+      level: {
+        type: 'string',
+        enum: ['info', 'warning', 'critical'],
+        description: '알림 레벨 필터'
+      },
+      type: {
+        type: 'string',
+        enum: ['response_time', 'memory_usage', 'error_rate', 'throughput', 'database_performance', 'cache_performance'],
+        description: '알림 타입 필터'
+      },
+      resolved: {
+        type: 'boolean',
+        description: '해결된 알림 포함 여부'
+      },
+      limit: {
+        type: 'number',
+        minimum: 1,
+        maximum: 100,
+        default: 50,
+        description: '결과 제한 수'
+      },
+      alertId: {
+        type: 'string',
+        description: '해결할 알림 ID (resolve 작업시)'
+      },
+      resolvedBy: {
+        type: 'string',
+        default: 'system',
+        description: '해결 처리자'
+      },
+      resolution: {
+        type: 'string',
+        description: '해결 사유'
+      }
+    },
+    required: []
+  }
+};
+
+export async function executePerformanceAlerts(args: any, context: ToolContext) {
+  const { action, hours, level, type, resolved, limit, alertId, resolvedBy, resolution } = args;
+  
+  try {
+    // 성능 알림 서비스가 없으면 기본 응답
+    if (!context.services.performanceAlertService) {
+      return {
+        success: false,
+        error: 'Performance alert service not available',
+        stats: {
+          totalAlerts: 0,
+          alertsByLevel: { info: 0, warning: 0, critical: 0 },
+          alertsByType: { response_time: 0, memory_usage: 0, error_rate: 0, throughput: 0, database_performance: 0, cache_performance: 0 },
+          recentAlerts: [],
+          averageResolutionTime: 0,
+          activeAlerts: 0
+        }
+      };
+    }
+
+    switch (action) {
+      case 'stats':
+        return await handleStats(context, hours);
+      
+      case 'list':
+        return await handleList(context, hours, limit);
+      
+      case 'search':
+        return await handleSearch(context, { level, type, resolved, hours, limit });
+      
+      case 'resolve':
+        return await handleResolve(context, alertId, resolvedBy, resolution);
+      
+      default:
+        return {
+          success: false,
+          error: `Unknown action: ${action}`
+        };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    };
+  }
+}
+
+async function handleStats(context: ToolContext, hours: number) {
+  const stats = context.services.performanceAlertService.getAlertStats(hours);
+  
+  return {
+    success: true,
+    stats: {
+      ...stats,
+      recentAlerts: stats.recentAlerts.map((alert: any) => ({
+        id: alert.id,
+        timestamp: alert.timestamp.toISOString(),
+        level: alert.level,
+        type: alert.type,
+        metric: alert.metric,
+        value: alert.value,
+        threshold: alert.threshold,
+        message: alert.message,
+        resolved: alert.resolved,
+        resolvedAt: alert.resolvedAt?.toISOString()
+      }))
+    },
+    summary: {
+      totalAlerts: stats.totalAlerts,
+      activeAlerts: stats.activeAlerts,
+      criticalAlerts: stats.alertsByLevel.critical,
+      averageResolutionTime: Math.round(stats.averageResolutionTime / 1000) // 초 단위로 변환
+    }
+  };
+}
+
+async function handleList(context: ToolContext, hours: number, limit: number) {
+  const activeAlerts = context.services.performanceAlertService.getActiveAlerts();
+  const recentAlerts = context.services.performanceAlertService.searchAlerts({
+    startDate: new Date(Date.now() - hours * 60 * 60 * 1000),
+    limit
+  });
+
+  return {
+    success: true,
+    activeAlerts: activeAlerts.map((alert: any) => ({
+      id: alert.id,
+      timestamp: alert.timestamp.toISOString(),
+      level: alert.level,
+      type: alert.type,
+      metric: alert.metric,
+      value: alert.value,
+      threshold: alert.threshold,
+      message: alert.message,
+      context: alert.context
+    })),
+    recentAlerts: recentAlerts.map((alert: any) => ({
+      id: alert.id,
+      timestamp: alert.timestamp.toISOString(),
+      level: alert.level,
+      type: alert.type,
+      metric: alert.metric,
+      value: alert.value,
+      threshold: alert.threshold,
+      message: alert.message,
+      resolved: alert.resolved,
+      resolvedAt: alert.resolvedAt?.toISOString()
+    }))
+  };
+}
+
+async function handleSearch(context: ToolContext, filters: any) {
+  const alerts = context.services.performanceAlertService.searchAlerts(filters);
+
+  return {
+    success: true,
+    alerts: alerts.map((alert: any) => ({
+      id: alert.id,
+      timestamp: alert.timestamp.toISOString(),
+      level: alert.level,
+      type: alert.type,
+      metric: alert.metric,
+      value: alert.value,
+      threshold: alert.threshold,
+      message: alert.message,
+      context: alert.context,
+      resolved: alert.resolved,
+      resolvedAt: alert.resolvedAt?.toISOString()
+    })),
+    total: alerts.length
+  };
+}
+
+async function handleResolve(context: ToolContext, alertId: string | undefined, resolvedBy: string, resolution?: string) {
+  if (!alertId) {
+    return {
+      success: false,
+      error: 'Alert ID is required for resolve action'
+    };
+  }
+
+  const success = context.services.performanceAlertService.resolveAlert(alertId, resolvedBy, resolution);
+  
+  if (!success) {
+    return {
+      success: false,
+      error: 'Alert not found or already resolved',
+      alertId
+    };
+  }
+
+  return {
+    success: true,
+    message: `Alert ${alertId} has been resolved by ${resolvedBy}`,
+    alertId,
+    resolvedBy,
+    resolution,
+    resolvedAt: new Date().toISOString()
+  };
+}

package/src/tools/performance-stats-tool.ts

@@ -0,0 +1,48 @@
+/**
+ * Performance Stats Tool - 성능 통계 도구
+ */
+
+import { z } from 'zod';
+import { BaseTool } from './base-tool.js';
+import type { ToolContext, ToolResult } from './types.js';
+
+const PerformanceStatsSchema = z.object({});
+
+export class PerformanceStatsTool extends BaseTool {
+  constructor() {
+    super(
+      'performance_stats',
+      '성능 통계를 조회합니다',
+      {
+        type: 'object',
+        properties: {}
+      }
+    );
+  }
+
+  async handle(params: any, context: ToolContext): Promise<ToolResult> {
+    // 데이터베이스 연결 확인
+    this.validateDatabase(context);
+    
+    // 성능 모니터 확인
+    this.validateService(context.services.performanceMonitor, '성능 모니터');
+    
+    try {
+      const metrics = await context.services.performanceMonitor.collectMetrics();
+      const report = await context.services.performanceMonitor.generateReport();
+      
+      return this.createSuccessResult({
+        metrics: {
+          database: metrics.database,
+          search: metrics.search,
+          memory: metrics.memory,
+          system: metrics.system
+        },
+        report: report,
+        message: '성능 통계 조회 완료'
+      });
+    } catch (error) {
+      throw new Error(`성능 통계 조회 실패: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+}