mcp-context-engineering
Version:
The intelligent context optimization system for AI coding assistants. Built with Cole's PRP methodology, Context Portal knowledge graphs, and production-ready MongoDB architecture.
670 lines (669 loc) • 25.3 kB
JavaScript
import { z } from 'zod';
import { cacheManager } from './cacheManager.js';
/**
* Performance Optimizer - Octocode-inspired optimization patterns
*
* Implements advanced performance patterns:
* - Parallel processing with intelligent batching
* - Progressive complexity reduction
* - Smart content selection and compression
* - Token usage optimization (80-90% reduction)
* - Adaptive query refinement
* - Performance monitoring and auto-tuning
*/
// Performance configuration schema
export const PerformanceConfigSchema = z.object({
parallel_processing: z.object({
enabled: z.boolean().default(true),
max_concurrent: z.number().default(10),
batch_size: z.number().default(50),
timeout_ms: z.number().default(30000)
}),
content_optimization: z.object({
enabled: z.boolean().default(true),
max_content_length: z.number().default(50000),
compression_level: z.enum(['none', 'basic', 'aggressive']).default('basic'),
token_target_reduction: z.number().min(0).max(0.95).default(0.8)
}),
query_optimization: z.object({
enabled: z.boolean().default(true),
adaptive_refinement: z.boolean().default(true),
complexity_reduction: z.boolean().default(true),
fallback_strategies: z.number().default(3)
}),
monitoring: z.object({
enabled: z.boolean().default(true),
metrics_window_ms: z.number().default(60000),
auto_tuning: z.boolean().default(true),
performance_threshold_ms: z.number().default(5000)
})
});
// Performance metrics schema
export const PerformanceMetricsSchema = z.object({
response_times: z.object({
avg_ms: z.number().default(0),
p50_ms: z.number().default(0),
p95_ms: z.number().default(0),
p99_ms: z.number().default(0)
}),
throughput: z.object({
requests_per_second: z.number().default(0),
tokens_per_second: z.number().default(0),
concurrent_requests: z.number().default(0)
}),
optimization: z.object({
token_savings_percent: z.number().default(0),
cache_hit_rate: z.number().default(0),
compression_ratio: z.number().default(0),
parallel_efficiency: z.number().default(0)
}),
errors: z.object({
timeout_rate: z.number().default(0),
error_rate: z.number().default(0),
retry_rate: z.number().default(0)
}),
resource_usage: z.object({
memory_usage_mb: z.number().default(0),
cpu_usage_percent: z.number().default(0),
network_usage_mb: z.number().default(0)
}),
last_updated: z.date()
});
// Processing task schema
export const ProcessingTaskSchema = z.object({
id: z.string(),
type: z.enum(['embedding', 'search', 'prp_generation', 'context_assembly']),
priority: z.enum(['low', 'normal', 'high', 'critical']).default('normal'),
input_data: z.any(),
context: z.object({
workspace_id: z.string().optional(),
project_id: z.string().optional(),
agent_type: z.string().optional(),
user_id: z.string().optional()
}),
// Performance requirements
max_response_time_ms: z.number().default(30000),
token_budget: z.number().optional(),
quality_threshold: z.number().min(0).max(1).default(0.8),
// Processing metadata
created_at: z.date(),
started_at: z.date().optional(),
completed_at: z.date().optional(),
status: z.enum(['pending', 'processing', 'completed', 'failed', 'timeout']).default('pending'),
error_message: z.string().optional(),
retry_count: z.number().default(0),
// Results
result: z.any().optional(),
performance_stats: z.object({
processing_time_ms: z.number(),
token_usage: z.number(),
cache_used: z.boolean(),
optimization_applied: z.array(z.string())
}).optional()
});
/**
* Advanced Performance Optimizer
*/
export class PerformanceOptimizer {
config;
metrics;
taskQueue;
processingTasks;
responseTimes;
metricsInterval;
constructor(config = {}) {
this.config = PerformanceConfigSchema.parse(config);
this.metrics = PerformanceMetricsSchema.parse({ last_updated: new Date() });
this.taskQueue = new Map();
this.processingTasks = new Set();
this.responseTimes = [];
if (this.config.monitoring.enabled) {
this.startMetricsCollection();
}
}
/**
* Process tasks with intelligent optimization
*/
async processTask(task, processor) {
const taskId = this.generateTaskId();
const startTime = Date.now();
const fullTask = {
...task,
id: taskId,
created_at: new Date(),
status: 'pending'
};
// Add to queue
this.taskQueue.set(taskId, fullTask);
try {
// Check cache first
const cacheResult = await this.checkCache(fullTask);
if (cacheResult) {
return {
result: cacheResult.result,
performance: {
processing_time_ms: Date.now() - startTime,
token_usage: 0,
cache_used: true,
optimization_applied: ['cache_hit']
}
};
}
// Apply pre-processing optimizations
const optimizedTask = await this.optimizeTask(fullTask);
// Process with monitoring
optimizedTask.status = 'processing';
optimizedTask.started_at = new Date();
this.processingTasks.add(taskId);
const result = await this.executeWithOptimization(optimizedTask, processor);
const endTime = Date.now();
const processingTime = endTime - startTime;
// Update task status
optimizedTask.status = 'completed';
optimizedTask.completed_at = new Date();
optimizedTask.result = result;
optimizedTask.performance_stats = {
processing_time_ms: processingTime,
token_usage: this.estimateTokenUsage(result),
cache_used: false,
optimization_applied: this.getAppliedOptimizations(optimizedTask)
};
// Cache result for future use
await this.cacheResult(optimizedTask, result);
// Update metrics
this.updateMetrics(processingTime, optimizedTask.performance_stats);
return {
result,
performance: optimizedTask.performance_stats
};
}
catch (error) {
const processingTime = Date.now() - startTime;
fullTask.status = 'failed';
fullTask.error_message = error instanceof Error ? error.message : 'Unknown error';
this.updateErrorMetrics(processingTime);
throw error;
}
finally {
this.processingTasks.delete(taskId);
this.taskQueue.delete(taskId);
}
}
/**
* Batch process multiple tasks with intelligent optimization
*/
async processBatch(tasks, processor) {
if (!this.config.parallel_processing.enabled) {
// Sequential processing
const results = [];
for (const task of tasks) {
results.push(await this.processTask(task, processor));
}
return results;
}
const batchSize = Math.min(this.config.parallel_processing.batch_size, this.config.parallel_processing.max_concurrent);
const results = [];
// Process in batches
for (let i = 0; i < tasks.length; i += batchSize) {
const batch = tasks.slice(i, i + batchSize);
const batchPromises = batch.map(task => this.processTask(task, processor).catch(error => ({ error, task })));
const batchResults = await Promise.all(batchPromises);
for (const result of batchResults) {
if ('error' in result) {
throw result.error;
}
else {
results.push(result);
}
}
}
return results;
}
/**
* Optimize content for token efficiency
*/
async optimizeContent(content, options = {}) {
if (!this.config.content_optimization.enabled) {
return {
optimized_content: content,
compression_ratio: 1,
token_reduction: 0
};
}
const originalLength = content.length;
const targetLength = options.target_length ||
Math.floor(originalLength * (1 - this.config.content_optimization.token_target_reduction));
let optimizedContent = content;
// Apply compression based on level
const compressionLevel = options.compression_level || this.config.content_optimization.compression_level;
switch (compressionLevel) {
case 'basic':
optimizedContent = this.basicContentOptimization(content, targetLength);
break;
case 'aggressive':
optimizedContent = this.aggressiveContentOptimization(content, targetLength, options.preserve_structure);
break;
case 'none':
default:
// No optimization
break;
}
const finalLength = optimizedContent.length;
const compressionRatio = originalLength > 0 ? finalLength / originalLength : 1;
const tokenReduction = Math.max(0, originalLength - finalLength);
return {
optimized_content: optimizedContent,
compression_ratio: compressionRatio,
token_reduction: tokenReduction
};
}
/**
* Progressive query refinement with fallback strategies
*/
async refineQuery(originalQuery, context, previousResults) {
if (!this.config.query_optimization.enabled) {
return {
refined_query: originalQuery,
strategy_used: 'none',
confidence: 1.0
};
}
// Strategy 1: Context-based refinement
if (this.config.query_optimization.adaptive_refinement) {
const contextRefined = this.refineWithContext(originalQuery, context);
if (contextRefined.confidence > 0.8) {
return {
refined_query: contextRefined.query,
strategy_used: 'context_refinement',
confidence: contextRefined.confidence
};
}
}
// Strategy 2: Complexity reduction
if (this.config.query_optimization.complexity_reduction) {
const simplified = this.simplifyQuery(originalQuery);
if (simplified.confidence > 0.7) {
return {
refined_query: simplified.query,
strategy_used: 'complexity_reduction',
confidence: simplified.confidence
};
}
}
// Strategy 3: Previous results analysis
if (previousResults && previousResults.length > 0) {
const resultRefined = this.refineFromResults(originalQuery, previousResults);
return {
refined_query: resultRefined.query,
strategy_used: 'result_based_refinement',
confidence: resultRefined.confidence
};
}
// Fallback: Return original query
return {
refined_query: originalQuery,
strategy_used: 'fallback',
confidence: 0.5
};
}
/**
* Basic content optimization
*/
basicContentOptimization(content, targetLength) {
if (content.length <= targetLength) {
return content;
}
// Remove excessive whitespace
let optimized = content.replace(/\s+/g, ' ').trim();
// Remove common redundant phrases
optimized = optimized.replace(/\b(?:in order to|that is to say|it should be noted that)\b/gi, '');
// Truncate if still too long
if (optimized.length > targetLength) {
optimized = optimized.substring(0, targetLength - 3) + '...';
}
return optimized;
}
/**
* Aggressive content optimization
*/
aggressiveContentOptimization(content, targetLength, preserveStructure) {
let optimized = this.basicContentOptimization(content, targetLength);
if (optimized.length <= targetLength) {
return optimized;
}
// Extract key sentences
const sentences = optimized.split(/[.!?]+/).filter(s => s.trim().length > 0);
const importantSentences = this.extractImportantSentences(sentences, targetLength);
if (preserveStructure) {
// Maintain original structure but use shorter sentences
return importantSentences.join('. ') + '.';
}
else {
// Aggressive compression
return this.compressToKeywords(importantSentences.join(' '), targetLength);
}
}
/**
* Extract important sentences based on keyword density
*/
extractImportantSentences(sentences, targetLength) {
const scored = sentences.map(sentence => ({
sentence: sentence.trim(),
score: this.calculateSentenceImportance(sentence)
}));
// Sort by importance and select sentences that fit target length
scored.sort((a, b) => b.score - a.score);
const selected = [];
let currentLength = 0;
for (const item of scored) {
if (currentLength + item.sentence.length <= targetLength) {
selected.push(item.sentence);
currentLength += item.sentence.length;
}
}
return selected;
}
/**
* Calculate sentence importance score
*/
calculateSentenceImportance(sentence) {
const importantWords = [
'implement', 'create', 'build', 'require', 'ensure', 'must', 'should',
'critical', 'important', 'key', 'main', 'primary', 'essential',
'error', 'issue', 'problem', 'solution', 'fix', 'resolve'
];
const words = sentence.toLowerCase().split(/\s+/);
const importantWordCount = words.filter(word => importantWords.some(imp => word.includes(imp))).length;
// Score based on important word density and sentence length
const density = importantWordCount / words.length;
const lengthScore = Math.min(words.length / 20, 1); // Prefer medium-length sentences
return density * 0.7 + lengthScore * 0.3;
}
/**
* Compress text to key keywords and phrases
*/
compressToKeywords(text, targetLength) {
const words = text.split(/\s+/);
const keywords = this.extractKeywords(words);
let compressed = keywords.join(' ');
if (compressed.length > targetLength) {
// Take top keywords that fit
let result = '';
for (const keyword of keywords) {
if (result.length + keyword.length + 1 <= targetLength) {
result += (result ? ' ' : '') + keyword;
}
else {
break;
}
}
compressed = result;
}
return compressed;
}
/**
* Extract keywords from text
*/
extractKeywords(words) {
const stopWords = new Set([
'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
'of', 'with', 'by', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
'should', 'may', 'might', 'can', 'this', 'that', 'these', 'those'
]);
return words
.filter(word => !stopWords.has(word.toLowerCase()) && word.length > 2)
.filter((word, index, arr) => arr.indexOf(word) === index) // Remove duplicates
.slice(0, 50); // Limit to top 50 keywords
}
/**
* Refine query with context information
*/
refineWithContext(query, context) {
if (!context) {
return { query, confidence: 0.5 };
}
let refinedQuery = query;
let confidence = 0.5;
// Add tech stack context
if (context.tech_stack && context.tech_stack.length > 0) {
refinedQuery += ` using ${context.tech_stack.join(', ')}`;
confidence += 0.2;
}
// Add project type context
if (context.project_type) {
refinedQuery += ` for ${context.project_type} project`;
confidence += 0.1;
}
// Add complexity context
if (context.complexity) {
refinedQuery += ` with ${context.complexity} complexity`;
confidence += 0.1;
}
return { query: refinedQuery, confidence: Math.min(confidence, 1.0) };
}
/**
* Simplify complex queries
*/
simplifyQuery(query) {
// Remove complex phrases and simplify language
let simplified = query
.replace(/\b(?:furthermore|moreover|additionally|consequently|therefore)\b/gi, 'and')
.replace(/\b(?:in order to|so as to)\b/gi, 'to')
.replace(/\b(?:due to the fact that|because of the fact that)\b/gi, 'because')
.replace(/\s+/g, ' ')
.trim();
const complexityReduction = (query.length - simplified.length) / query.length;
const confidence = 0.5 + complexityReduction * 0.3;
return { query: simplified, confidence };
}
/**
* Refine query based on previous results
*/
refineFromResults(query, results) {
// Analyze previous results to refine query
// This is a simplified implementation
return { query, confidence: 0.6 };
}
/**
* Check cache for existing results
*/
async checkCache(task) {
const cacheKey = this.generateCacheKey(task);
const cached = await cacheManager.get(cacheKey, task.context);
if (cached) {
console.log(`📋 Cache hit for task ${task.id} (${cached.hit_type})`);
return { result: cached.value };
}
return null;
}
/**
* Cache processing result
*/
async cacheResult(task, result) {
const cacheKey = this.generateCacheKey(task);
await cacheManager.set(cacheKey, result, {
ttl_seconds: 3600, // 1 hour
content_type: task.type,
semantic_context: task.context
});
}
/**
* Generate cache key for task
*/
generateCacheKey(task) {
const keyData = {
type: task.type,
input: JSON.stringify(task.input_data),
context: task.context
};
return `task:${Buffer.from(JSON.stringify(keyData)).toString('base64')}`;
}
/**
* Optimize task before processing
*/
async optimizeTask(task) {
const optimized = { ...task };
// Optimize input data if it's content
if (typeof task.input_data === 'string') {
const contentOpt = await this.optimizeContent(task.input_data);
optimized.input_data = contentOpt.optimized_content;
}
else if (task.input_data && typeof task.input_data === 'object') {
// Optimize object content
optimized.input_data = await this.optimizeObjectContent(task.input_data);
}
return optimized;
}
/**
* Optimize object content recursively
*/
async optimizeObjectContent(obj) {
if (typeof obj === 'string') {
const optimized = await this.optimizeContent(obj);
return optimized.optimized_content;
}
if (Array.isArray(obj)) {
return Promise.all(obj.map(item => this.optimizeObjectContent(item)));
}
if (typeof obj === 'object' && obj !== null) {
const optimized = {};
for (const [key, value] of Object.entries(obj)) {
optimized[key] = await this.optimizeObjectContent(value);
}
return optimized;
}
return obj;
}
/**
* Execute task with performance monitoring
*/
async executeWithOptimization(task, processor) {
const startTime = Date.now();
const timeout = task.max_response_time_ms;
const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Task timeout')), timeout));
try {
const result = await Promise.race([
processor(task),
timeoutPromise
]);
const processingTime = Date.now() - startTime;
console.log(`⚡ Task ${task.id} completed in ${processingTime}ms`);
return result;
}
catch (error) {
if (error instanceof Error && error.message === 'Task timeout') {
task.status = 'timeout';
console.log(`⏰ Task ${task.id} timed out after ${timeout}ms`);
}
throw error;
}
}
/**
* Generate unique task ID
*/
generateTaskId() {
return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}
/**
* Estimate token usage for result
*/
estimateTokenUsage(result) {
const resultStr = JSON.stringify(result);
// Rough estimation: 1 token ≈ 4 characters
return Math.ceil(resultStr.length / 4);
}
/**
* Get applied optimizations for task
*/
getAppliedOptimizations(task) {
const optimizations = [];
if (this.config.content_optimization.enabled) {
optimizations.push('content_optimization');
}
if (this.config.parallel_processing.enabled) {
optimizations.push('parallel_processing');
}
if (this.config.query_optimization.enabled) {
optimizations.push('query_optimization');
}
return optimizations;
}
/**
* Update performance metrics
*/
updateMetrics(processingTime, performanceStats) {
this.responseTimes.push(processingTime);
// Keep only recent response times (last 1000)
if (this.responseTimes.length > 1000) {
this.responseTimes = this.responseTimes.slice(-1000);
}
// Update response time metrics
this.metrics.response_times.avg_ms = this.responseTimes.reduce((a, b) => a + b, 0) / this.responseTimes.length;
const sorted = [...this.responseTimes].sort((a, b) => a - b);
this.metrics.response_times.p50_ms = sorted[Math.floor(sorted.length * 0.5)];
this.metrics.response_times.p95_ms = sorted[Math.floor(sorted.length * 0.95)];
this.metrics.response_times.p99_ms = sorted[Math.floor(sorted.length * 0.99)];
// Update optimization metrics
if (performanceStats) {
if (performanceStats.cache_used) {
const cacheStats = cacheManager.getStats();
this.metrics.optimization.cache_hit_rate = cacheStats.hit_rate;
}
if (performanceStats.token_usage > 0) {
// Estimate token savings (simplified)
this.metrics.optimization.token_savings_percent =
this.config.content_optimization.token_target_reduction * 100;
}
}
this.metrics.last_updated = new Date();
}
/**
* Update error metrics
*/
updateErrorMetrics(processingTime) {
// Update error rates (simplified implementation)
this.metrics.errors.error_rate = Math.min(this.metrics.errors.error_rate + 0.01, 1.0);
this.metrics.last_updated = new Date();
}
/**
* Start metrics collection
*/
startMetricsCollection() {
this.metricsInterval = setInterval(() => {
// Update throughput metrics
this.metrics.throughput.concurrent_requests = this.processingTasks.size;
// Update resource usage (simplified)
this.metrics.resource_usage.memory_usage_mb = process.memoryUsage().heapUsed / 1024 / 1024;
this.metrics.last_updated = new Date();
}, this.config.monitoring.metrics_window_ms);
}
/**
* Get current performance metrics
*/
getMetrics() {
return { ...this.metrics };
}
/**
* Get current task queue status
*/
getTaskQueueStatus() {
return {
pending: this.taskQueue.size - this.processingTasks.size,
processing: this.processingTasks.size,
total_capacity: this.config.parallel_processing.max_concurrent
};
}
/**
* Shutdown performance optimizer
*/
shutdown() {
if (this.metricsInterval) {
clearInterval(this.metricsInterval);
}
this.taskQueue.clear();
this.processingTasks.clear();
}
}
// Export singleton instance
export const performanceOptimizer = new PerformanceOptimizer();