memento-mcp-server 0.1.0

package/packages/mcp-client/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@memento/client",
+  "version": "0.1.0",
+  "description": "Memento MCP Server client library for AI Agents",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "dev": "tsc --watch",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "memento",
+    "mcp",
+    "memory",
+    "ai",
+    "agent",
+    "context",
+    "typescript"
+  ],
+  "author": "Memento Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-org/memento.git",
+    "directory": "packages/mcp-client"
+  },
+  "bugs": {
+    "url": "https://github.com/your-org/memento/issues"
+  },
+  "homepage": "https://github.com/your-org/memento#readme",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.12.2",
+    "ws": "^8.14.0"
+  },
+  "devDependencies": {
+    "@types/axios": "^0.9.36",
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.0",
+    "rimraf": "^5.0.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/mcp-client/performance-optimizer.js

@@ -0,0 +1,428 @@
+/**
+ * @memento/client 성능 최적화 도구
+ * 
+ * 대용량 데이터 처리와 성능 향상을 위한 최적화 기능들을 제공합니다.
+ */
+
+const { MementoClient, MemoryManager, ContextInjector } = require('./dist/index.js');
+
+class PerformanceOptimizer {
+  constructor(client) {
+    this.client = client;
+    this.manager = new MemoryManager(client);
+    this.injector = new ContextInjector(client);
+    
+    // 성능 메트릭
+    this.metrics = {
+      requestCount: 0,
+      totalResponseTime: 0,
+      cacheHits: 0,
+      cacheMisses: 0,
+      batchOperations: 0
+    };
+    
+    // 요청 캐시
+    this.requestCache = new Map();
+    this.cacheTimeout = 5 * 60 * 1000; // 5분
+  }
+
+  /**
+   * 배치 처리를 위한 메모리 생성
+   */
+  async createMemoriesBatch(memories, options = {}) {
+    const {
+      batchSize = 10,
+      delayBetweenBatches = 100,
+      onProgress = null
+    } = options;
+
+    const results = [];
+    const totalBatches = Math.ceil(memories.length / batchSize);
+    
+    console.log(`📦 배치 처리 시작: ${memories.length}개 기억을 ${totalBatches}개 배치로 처리`);
+
+    for (let i = 0; i < memories.length; i += batchSize) {
+      const batch = memories.slice(i, i + batchSize);
+      const batchNumber = Math.floor(i / batchSize) + 1;
+      
+      try {
+        const startTime = Date.now();
+        const batchResults = await this.manager.createBatch(batch);
+        const batchTime = Date.now() - startTime;
+        
+        results.push(...batchResults);
+        this.metrics.batchOperations++;
+        
+        if (onProgress) {
+          onProgress({
+            batchNumber,
+            totalBatches,
+            processed: Math.min(i + batchSize, memories.length),
+            total: memories.length,
+            batchTime,
+            success: batchResults.length
+          });
+        }
+        
+        console.log(`  배치 ${batchNumber}/${totalBatches} 완료: ${batchResults.length}개 생성 (${batchTime}ms)`);
+        
+        // 배치 간 지연
+        if (i + batchSize < memories.length && delayBetweenBatches > 0) {
+          await this.delay(delayBetweenBatches);
+        }
+        
+      } catch (error) {
+        console.error(`  배치 ${batchNumber} 실패:`, error.message);
+        // 실패한 배치는 건너뛰고 계속 진행
+      }
+    }
+
+    console.log(`✅ 배치 처리 완료: ${results.length}개 기억 생성`);
+    return results;
+  }
+
+  /**
+   * 병렬 검색 최적화
+   */
+  async parallelSearch(queries, options = {}) {
+    const {
+      maxConcurrency = 5,
+      timeout = 10000
+    } = options;
+
+    console.log(`🔍 병렬 검색 시작: ${queries.length}개 쿼리, 최대 동시성: ${maxConcurrency}`);
+
+    const results = [];
+    const semaphore = new Semaphore(maxConcurrency);
+
+    const searchPromises = queries.map(async (query, index) => {
+      await semaphore.acquire();
+      
+      try {
+        const startTime = Date.now();
+        const result = await Promise.race([
+          this.manager.search(query, { limit: 10 }),
+          this.timeoutPromise(timeout)
+        ]);
+        
+        const searchTime = Date.now() - startTime;
+        this.recordMetric(searchTime);
+        
+        return {
+          index,
+          query,
+          result,
+          searchTime,
+          success: true
+        };
+        
+      } catch (error) {
+        return {
+          index,
+          query,
+          error: error.message,
+          success: false
+        };
+      } finally {
+        semaphore.release();
+      }
+    });
+
+    const searchResults = await Promise.all(searchPromises);
+    results.push(...searchResults);
+
+    const successful = searchResults.filter(r => r.success).length;
+    console.log(`✅ 병렬 검색 완료: ${successful}/${queries.length}개 성공`);
+
+    return results;
+  }
+
+  /**
+   * 캐시를 활용한 검색 최적화
+   */
+  async cachedSearch(query, options = {}) {
+    const cacheKey = this.generateCacheKey('search', query, options);
+    const cached = this.requestCache.get(cacheKey);
+    
+    if (cached && Date.now() - cached.timestamp < this.cacheTimeout) {
+      this.metrics.cacheHits++;
+      console.log(`💾 캐시 히트: ${query}`);
+      return cached.data;
+    }
+
+    this.metrics.cacheMisses++;
+    const startTime = Date.now();
+    
+    try {
+      const result = await this.manager.search(query, options);
+      const responseTime = Date.now() - startTime;
+      
+      // 캐시에 저장
+      this.requestCache.set(cacheKey, {
+        data: result,
+        timestamp: Date.now()
+      });
+      
+      this.recordMetric(responseTime);
+      return result;
+      
+    } catch (error) {
+      console.error(`검색 실패: ${query}`, error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * 스트리밍 검색 (대용량 결과 처리)
+   */
+  async *streamSearch(query, options = {}) {
+    const {
+      pageSize = 50,
+      maxPages = 20
+    } = options;
+
+    console.log(`🌊 스트리밍 검색 시작: ${query}`);
+
+    let page = 0;
+    let hasMore = true;
+    let totalProcessed = 0;
+
+    while (hasMore && page < maxPages) {
+      try {
+        const searchOptions = {
+          ...options,
+          limit: pageSize,
+          offset: page * pageSize
+        };
+
+        const result = await this.manager.search(query, searchOptions);
+        
+        if (result.items.length === 0) {
+          hasMore = false;
+        } else {
+          totalProcessed += result.items.length;
+          yield {
+            page,
+            items: result.items,
+            totalCount: result.total_count,
+            processed: totalProcessed
+          };
+          
+          page++;
+        }
+        
+      } catch (error) {
+        console.error(`스트리밍 검색 오류 (페이지 ${page}):`, error.message);
+        break;
+      }
+    }
+
+    console.log(`✅ 스트리밍 검색 완료: ${totalProcessed}개 항목 처리`);
+  }
+
+  /**
+   * 메모리 사용량 최적화를 위한 압축 검색
+   */
+  async compressedSearch(query, options = {}) {
+    const {
+      maxResults = 100,
+      compressionRatio = 0.7
+    } = options;
+
+    console.log(`🗜️ 압축 검색 시작: ${query}`);
+
+    // 1. 더 많은 결과를 가져옴
+    const expandedOptions = {
+      ...options,
+      limit: Math.ceil(maxResults / compressionRatio)
+    };
+
+    const fullResults = await this.manager.search(query, expandedOptions);
+    
+    // 2. 결과 압축 (중요도와 점수 기반)
+    const compressedItems = fullResults.items
+      .sort((a, b) => (b.score || 0) - (a.score || 0))
+      .slice(0, maxResults);
+
+    // 3. 압축된 결과 반환
+    return {
+      items: compressedItems,
+      total_count: compressedItems.length,
+      query_time: fullResults.query_time,
+      compressed: true,
+      original_count: fullResults.items.length
+    };
+  }
+
+  /**
+   * 성능 벤치마크 실행
+   */
+  async runBenchmark(options = {}) {
+    const {
+      testDataSize = 100,
+      iterations = 5
+    } = options;
+
+    console.log(`🏁 성능 벤치마크 시작: ${testDataSize}개 데이터, ${iterations}회 반복`);
+
+    const benchmarks = {
+      createMemory: [],
+      searchMemory: [],
+      contextInjection: []
+    };
+
+    // 테스트 데이터 생성
+    const testMemories = Array.from({ length: testDataSize }, (_, i) => ({
+      content: `벤치마크 테스트 데이터 ${i + 1}: TypeScript와 React에 대한 상세한 학습 내용입니다.`,
+      type: 'episodic',
+      importance: Math.random(),
+      tags: ['benchmark', 'test', `data-${i}`],
+      source: 'benchmark-test'
+    }));
+
+    // 벤치마크 실행
+    for (let i = 0; i < iterations; i++) {
+      console.log(`  반복 ${i + 1}/${iterations}`);
+      
+      // 메모리 생성 벤치마크
+      const createStart = Date.now();
+      await this.createMemoriesBatch(testMemories, { batchSize: 20 });
+      benchmarks.createMemory.push(Date.now() - createStart);
+      
+      // 검색 벤치마크
+      const searchStart = Date.now();
+      await this.manager.search('TypeScript React', { limit: 50 });
+      benchmarks.searchMemory.push(Date.now() - searchStart);
+      
+      // 컨텍스트 주입 벤치마크
+      const contextStart = Date.now();
+      await this.injector.inject('프로그래밍 학습', { tokenBudget: 1000 });
+      benchmarks.contextInjection.push(Date.now() - contextStart);
+    }
+
+    // 결과 분석
+    const results = this.analyzeBenchmarkResults(benchmarks);
+    this.printBenchmarkResults(results);
+    
+    return results;
+  }
+
+  /**
+   * 성능 메트릭 수집
+   */
+  recordMetric(responseTime) {
+    this.metrics.requestCount++;
+    this.metrics.totalResponseTime += responseTime;
+  }
+
+  /**
+   * 성능 통계 조회
+   */
+  getPerformanceStats() {
+    const avgResponseTime = this.metrics.requestCount > 0 
+      ? this.metrics.totalResponseTime / this.metrics.requestCount 
+      : 0;
+
+    const cacheHitRate = this.metrics.cacheHits + this.metrics.cacheMisses > 0
+      ? (this.metrics.cacheHits / (this.metrics.cacheHits + this.metrics.cacheMisses)) * 100
+      : 0;
+
+    return {
+      totalRequests: this.metrics.requestCount,
+      averageResponseTime: Math.round(avgResponseTime),
+      cacheHitRate: Math.round(cacheHitRate * 100) / 100,
+      batchOperations: this.metrics.batchOperations,
+      cacheSize: this.requestCache.size
+    };
+  }
+
+  /**
+   * 캐시 정리
+   */
+  clearCache() {
+    this.requestCache.clear();
+    console.log('🧹 캐시가 정리되었습니다');
+  }
+
+  // 유틸리티 메서드들
+  generateCacheKey(operation, query, options) {
+    return `${operation}:${query}:${JSON.stringify(options)}`;
+  }
+
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  timeoutPromise(ms) {
+    return new Promise((_, reject) => 
+      setTimeout(() => reject(new Error('Operation timeout')), ms)
+    );
+  }
+
+  analyzeBenchmarkResults(benchmarks) {
+    const results = {};
+    
+    for (const [operation, times] of Object.entries(benchmarks)) {
+      times.sort((a, b) => a - b);
+      
+      results[operation] = {
+        min: times[0],
+        max: times[times.length - 1],
+        avg: Math.round(times.reduce((a, b) => a + b, 0) / times.length),
+        median: times[Math.floor(times.length / 2)],
+        p95: times[Math.floor(times.length * 0.95)]
+      };
+    }
+    
+    return results;
+  }
+
+  printBenchmarkResults(results) {
+    console.log('\n📊 벤치마크 결과');
+    console.log('='.repeat(60));
+    
+    for (const [operation, stats] of Object.entries(results)) {
+      console.log(`\n${operation}:`);
+      console.log(`  최소: ${stats.min}ms`);
+      console.log(`  최대: ${stats.max}ms`);
+      console.log(`  평균: ${stats.avg}ms`);
+      console.log(`  중간값: ${stats.median}ms`);
+      console.log(`  95%ile: ${stats.p95}ms`);
+    }
+    
+    console.log('\n' + '='.repeat(60));
+  }
+}
+
+/**
+ * 세마포어 클래스 (동시성 제어)
+ */
+class Semaphore {
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+    this.currentConcurrency = 0;
+    this.queue = [];
+  }
+
+  async acquire() {
+    return new Promise((resolve) => {
+      if (this.currentConcurrency < this.maxConcurrency) {
+        this.currentConcurrency++;
+        resolve();
+      } else {
+        this.queue.push(resolve);
+      }
+    });
+  }
+
+  release() {
+    this.currentConcurrency--;
+    if (this.queue.length > 0) {
+      const next = this.queue.shift();
+      this.currentConcurrency++;
+      next();
+    }
+  }
+}
+
+module.exports = { PerformanceOptimizer, Semaphore };

package/packages/mcp-client/test-basic.js

@@ -0,0 +1,65 @@
+/**
+ * @memento/client 기본 테스트
+ * 
+ * 이 파일은 클라이언트 라이브러리의 기본 기능을 테스트합니다.
+ */
+
+const { MementoClient, MemoryManager, ContextInjector } = require('./dist/index.js');
+
+async function testBasicFunctionality() {
+  console.log('🧪 @memento/client 기본 테스트 시작\n');
+
+  try {
+    // 1. 클라이언트 생성
+    console.log('1. 클라이언트 생성 중...');
+    const client = new MementoClient({
+      serverUrl: 'http://localhost:8080',
+      logLevel: 'info'
+    });
+    console.log('✅ 클라이언트 생성 완료');
+
+    // 2. MemoryManager 생성
+    console.log('\n2. MemoryManager 생성 중...');
+    const manager = new MemoryManager(client);
+    console.log('✅ MemoryManager 생성 완료');
+
+    // 3. ContextInjector 생성
+    console.log('\n3. ContextInjector 생성 중...');
+    const injector = new ContextInjector(client);
+    console.log('✅ ContextInjector 생성 완료');
+
+    // 4. 클라이언트 옵션 확인
+    console.log('\n4. 클라이언트 옵션 확인:');
+    const options = client.getOptions();
+    console.log(`  서버 URL: ${options.serverUrl}`);
+    console.log(`  타임아웃: ${options.timeout}ms`);
+    console.log(`  재시도 횟수: ${options.retryCount}`);
+    console.log(`  로그 레벨: ${options.logLevel}`);
+
+    // 5. 타입 검증 함수 테스트
+    console.log('\n5. 유틸리티 함수 테스트:');
+    const { isValidMemoryType, isValidPrivacyScope, isValidImportance } = require('./dist/utils.js');
+    
+    console.log(`  isValidMemoryType('episodic'): ${isValidMemoryType('episodic')}`);
+    console.log(`  isValidMemoryType('invalid'): ${isValidMemoryType('invalid')}`);
+    console.log(`  isValidPrivacyScope('private'): ${isValidPrivacyScope('private')}`);
+    console.log(`  isValidImportance(0.5): ${isValidImportance(0.5)}`);
+    console.log(`  isValidImportance(1.5): ${isValidImportance(1.5)}`);
+
+    console.log('\n✅ 모든 기본 테스트 통과!');
+    console.log('\n📝 참고: 실제 서버 연결 테스트를 위해서는 Memento MCP 서버가 실행 중이어야 합니다.');
+    console.log('   서버 실행: npm run dev:http');
+    console.log('   그 후 연결 테스트를 진행하세요.');
+
+  } catch (error) {
+    console.error('❌ 테스트 실패:', error.message);
+    console.error('스택 트레이스:', error.stack);
+  }
+}
+
+// 테스트 실행
+if (require.main === module) {
+  testBasicFunctionality().catch(console.error);
+}
+
+module.exports = { testBasicFunctionality };