MCP File Context Server

  • docs
# Technical Design: MCP File Context Server Initial Read Optimization ## 1. System Requirements ### 1.1 Hardware Requirements - CPU: Multi-core processor (recommended minimum 4 cores) - Memory: Minimum 8GB RAM, recommended 16GB for large codebases - Storage: SSD recommended for optimal I/O performance ### 1.2 Software Requirements - Node.js 18.0 or higher - TypeScript 4.5 or higher - Operating System: Cross-platform (Windows, Linux, macOS) ### 1.3 Dependencies ```typescript interface DependencyRequirements { required: { 'lru-cache': '^7.0.0', 'chokidar': '^3.5.0', '@modelcontextprotocol/sdk': '^1.0.0', 'mime-types': '^2.1.0' }, optional: { 'worker-threads': '^1.0.0', // For parallel processing 'node-worker-threads-pool': '^1.5.0' // For worker pool management } } ``` ## 2. Architecture Components ### 2.1 Memory Management System ```typescript interface MemoryConfig { maxCacheSize: number; // Maximum memory for cache in MB workerMemoryLimit: number; // Memory limit per worker in MB gcThreshold: number; // GC trigger threshold (0.8 = 80%) emergencyFreeThreshold: number; // Emergency memory release threshold } class MemoryManager { private memoryUsage: number; private totalAllocated: number; constructor(private config: MemoryConfig) { this.setupMemoryMonitoring(); } private setupMemoryMonitoring() { if (globalThis.gc) { // Register memory pressure handlers this.setupMemoryPressureHandlers(); } } private shouldTriggerGC(): boolean { const usage = process.memoryUsage(); return (usage.heapUsed / usage.heapTotal) > this.config.gcThreshold; } } ``` ### 2.2 Worker Pool Management ```typescript interface WorkerPoolConfig { minWorkers: number; maxWorkers: number; idleTimeout: number; // ms before releasing idle worker taskTimeout: number; // ms before task timeout } class WorkerPoolManager { private workerPool: Map<string, Worker>; private taskQueue: Queue<Task>; private activeWorkers: number; constructor(private config: WorkerPoolConfig) { this.initializeWorkerPool(); } private async initializeWorkerPool() { const initialWorkers = Math.min( this.config.minWorkers, os.cpus().length ); for (let i = 0; i < initialWorkers; i++) { await this.addWorker(); } } } ``` ### 2.3 Enhanced Cache Service Configuration ```typescript interface CacheConfig { maxSize: number; parallelProcessing: { enabled: boolean; maxWorkers?: number; chunkSize?: number; }; preloadStrategy: { enabled: boolean; maxPreloadItems: number; preloadDepth: number; }; progressiveLoading: { enabled: boolean; priorityLevels: number; }; memoryManagement: { maxMemoryPercent: number; gcThreshold: number; emergencyThreshold: number; }; storage: { persistToDisk: boolean; compressionLevel?: number; storageLocation?: string; }; } ``` ## 3. Core Components ### 3.1 Parallel File Reader Service ```typescript class ParallelFileReader { private workerPool: WorkerPoolManager; private memoryManager: MemoryManager; constructor(config: FileReaderConfig) { this.workerPool = new WorkerPoolManager({ minWorkers: 2, maxWorkers: os.cpus().length, idleTimeout: 60000, taskTimeout: 30000 }); this.memoryManager = new MemoryManager({ maxCacheSize: config.maxCacheSize, workerMemoryLimit: config.workerMemoryLimit, gcThreshold: 0.8, emergencyFreeThreshold: 0.95 }); } async readFileChunked(filepath: string, options: ReadOptions): Promise<FileContent> { const stats = await fs.stat(filepath); const chunks: Buffer[] = []; const chunkSize = this.calculateOptimalChunkSize(stats.size); // Distribute chunks to worker pool const chunkTasks = this.createChunkTasks(filepath, stats.size, chunkSize); const results = await this.workerPool.executeBatch(chunkTasks); return this.assembleResults(results, stats); } } ``` ### 3.2 Messaging Architecture ```typescript interface Message { id: string; type: MessageType; payload: any; metadata: { timestamp: number; priority: number; timeout?: number; }; } class MessageBroker { private subscriptions: Map<string, Set<MessageHandler>>; private priorityQueue: PriorityQueue<Message>; constructor() { this.subscriptions = new Map(); this.priorityQueue = new PriorityQueue(); } async publish(message: Message): Promise<void> { const handlers = this.subscriptions.get(message.type); if (handlers) { await Promise.all( Array.from(handlers).map(handler => handler(message.payload) ) ); } } } ``` ### 3.3 File Analysis Pipeline ```typescript interface AnalysisPipeline { stages: Array<{ name: string; processor: (chunk: Buffer) => Promise<AnalysisResult>; priority: number; }>; } class FileAnalyzer { private pipeline: AnalysisPipeline; private messageBroker: MessageBroker; constructor() { this.pipeline = { stages: [ { name: 'header', processor: this.analyzeFileHeader, priority: 1 }, { name: 'content', processor: this.analyzeContent, priority: 2 }, { name: 'metadata', processor: this.extractMetadata, priority: 3 } ] }; } } ``` ## 4. Performance Optimization Strategies ### 4.1 Memory Management Strategies ```typescript class OptimizedMemoryStrategy { private readonly BUFFER_POOL_SIZE = 8192; private bufferPool: Buffer[]; constructor() { this.bufferPool = Array(10).fill(null) .map(() => Buffer.allocUnsafe(this.BUFFER_POOL_SIZE)); } private acquireBuffer(): Buffer { return this.bufferPool.pop() || Buffer.allocUnsafe(this.BUFFER_POOL_SIZE); } private releaseBuffer(buffer: Buffer) { if (this.bufferPool.length < 10) { this.bufferPool.push(buffer); } } } ``` ### 4.2 Worker Thread Management ```typescript class WorkerThreadManager { private workers: Worker[]; private taskQueue: PriorityQueue<Task>; private activeWorkers: Set<Worker>; constructor(private config: WorkerConfig) { this.workers = []; this.taskQueue = new PriorityQueue(); this.activeWorkers = new Set(); } async executeTask(task: Task): Promise<Result> { const worker = await this.getAvailableWorker(); this.activeWorkers.add(worker); try { return await this.runTaskInWorker(worker, task); } finally { this.activeWorkers.delete(worker); this.releaseWorker(worker); } } } ``` ### 4.3 I/O Optimization ```typescript class IOOptimizer { private readonly PAGE_SIZE = 4096; private readonly READ_AHEAD = 4; constructor(private config: IOConfig) { this.initializeIOBuffers(); } private async readWithReadAhead( fd: number, position: number, size: number ): Promise<Buffer> { // Implement read-ahead buffering const readAheadSize = this.PAGE_SIZE * this.READ_AHEAD; const buffer = Buffer.allocUnsafe(readAheadSize); await fs.read(fd, buffer, 0, readAheadSize, position); return buffer.slice(0, size); } } ``` ## 5. Integration Points ### 5.1 Cache Service Integration ```typescript class EnhancedCacheService extends CacheService { private fileReader: ParallelFileReader; private memoryManager: MemoryManager; private messageBroker: MessageBroker; constructor(config: CacheServiceConfig) { super(config); this.initializeServices(config); } private async initializeServices(config: CacheServiceConfig) { this.fileReader = new ParallelFileReader(config); this.memoryManager = new MemoryManager(config.memoryManagement); this.messageBroker = new MessageBroker(); await this.setupMessageHandlers(); } } ``` ### 5.2 Event System Integration ```typescript interface EventConfig { maxListeners: number; errorThreshold: number; debugMode: boolean; } class EventSystem { private eventEmitter: EventEmitter; private errorCount: Map<string, number>; constructor(private config: EventConfig) { this.eventEmitter = new EventEmitter(); this.errorCount = new Map(); this.setupErrorHandling(); } private setupErrorHandling() { this.eventEmitter.on('error', (error: Error) => { this.handleError(error); }); } } ``` ## 6. Configuration Examples ### 6.1 Development Configuration ```typescript const devConfig: CacheServiceConfig = { maxSize: 1000, parallelProcessing: { enabled: true, maxWorkers: 4, chunkSize: 1024 * 1024 }, memoryManagement: { maxMemoryPercent: 70, gcThreshold: 0.8, emergencyThreshold: 0.95 }, storage: { persistToDisk: true, compressionLevel: 1, storageLocation: './cache' } }; ``` ### 6.2 Production Configuration ```typescript const prodConfig: CacheServiceConfig = { maxSize: 5000, parallelProcessing: { enabled: true, maxWorkers: 8, chunkSize: 2 * 1024 * 1024 }, memoryManagement: { maxMemoryPercent: 85, gcThreshold: 0.75, emergencyThreshold: 0.9 }, storage: { persistToDisk: true, compressionLevel: 4, storageLocation: '/var/cache/mcp' } }; ``` ### 6.3 Containerized Configuration ```typescript const containerConfig: CacheServiceConfig = { maxSize: 2000, parallelProcessing: { enabled: true, maxWorkers: 2, chunkSize: 512 * 1024 }, memoryManagement: { maxMemoryPercent: 60, gcThreshold: 0.7, emergencyThreshold: 0.85 }, storage: { persistToDisk: false } }; ```