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.
513 lines (512 loc) • 16.6 kB
TypeScript
import { z } from 'zod';
/**
* 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
*/
export declare const PerformanceConfigSchema: z.ZodObject<{
parallel_processing: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
max_concurrent: z.ZodDefault<z.ZodNumber>;
batch_size: z.ZodDefault<z.ZodNumber>;
timeout_ms: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
batch_size: number;
max_concurrent: number;
timeout_ms: number;
}, {
enabled?: boolean | undefined;
batch_size?: number | undefined;
max_concurrent?: number | undefined;
timeout_ms?: number | undefined;
}>;
content_optimization: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
max_content_length: z.ZodDefault<z.ZodNumber>;
compression_level: z.ZodDefault<z.ZodEnum<["none", "basic", "aggressive"]>>;
token_target_reduction: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
max_content_length: number;
compression_level: "basic" | "none" | "aggressive";
token_target_reduction: number;
}, {
enabled?: boolean | undefined;
max_content_length?: number | undefined;
compression_level?: "basic" | "none" | "aggressive" | undefined;
token_target_reduction?: number | undefined;
}>;
query_optimization: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
adaptive_refinement: z.ZodDefault<z.ZodBoolean>;
complexity_reduction: z.ZodDefault<z.ZodBoolean>;
fallback_strategies: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
adaptive_refinement: boolean;
complexity_reduction: boolean;
fallback_strategies: number;
}, {
enabled?: boolean | undefined;
adaptive_refinement?: boolean | undefined;
complexity_reduction?: boolean | undefined;
fallback_strategies?: number | undefined;
}>;
monitoring: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
metrics_window_ms: z.ZodDefault<z.ZodNumber>;
auto_tuning: z.ZodDefault<z.ZodBoolean>;
performance_threshold_ms: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
metrics_window_ms: number;
auto_tuning: boolean;
performance_threshold_ms: number;
}, {
enabled?: boolean | undefined;
metrics_window_ms?: number | undefined;
auto_tuning?: boolean | undefined;
performance_threshold_ms?: number | undefined;
}>;
}, "strip", z.ZodTypeAny, {
parallel_processing: {
enabled: boolean;
batch_size: number;
max_concurrent: number;
timeout_ms: number;
};
content_optimization: {
enabled: boolean;
max_content_length: number;
compression_level: "basic" | "none" | "aggressive";
token_target_reduction: number;
};
query_optimization: {
enabled: boolean;
adaptive_refinement: boolean;
complexity_reduction: boolean;
fallback_strategies: number;
};
monitoring: {
enabled: boolean;
metrics_window_ms: number;
auto_tuning: boolean;
performance_threshold_ms: number;
};
}, {
parallel_processing: {
enabled?: boolean | undefined;
batch_size?: number | undefined;
max_concurrent?: number | undefined;
timeout_ms?: number | undefined;
};
content_optimization: {
enabled?: boolean | undefined;
max_content_length?: number | undefined;
compression_level?: "basic" | "none" | "aggressive" | undefined;
token_target_reduction?: number | undefined;
};
query_optimization: {
enabled?: boolean | undefined;
adaptive_refinement?: boolean | undefined;
complexity_reduction?: boolean | undefined;
fallback_strategies?: number | undefined;
};
monitoring: {
enabled?: boolean | undefined;
metrics_window_ms?: number | undefined;
auto_tuning?: boolean | undefined;
performance_threshold_ms?: number | undefined;
};
}>;
export type PerformanceConfig = z.infer<typeof PerformanceConfigSchema>;
export declare const PerformanceMetricsSchema: z.ZodObject<{
response_times: z.ZodObject<{
avg_ms: z.ZodDefault<z.ZodNumber>;
p50_ms: z.ZodDefault<z.ZodNumber>;
p95_ms: z.ZodDefault<z.ZodNumber>;
p99_ms: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
avg_ms: number;
p50_ms: number;
p95_ms: number;
p99_ms: number;
}, {
avg_ms?: number | undefined;
p50_ms?: number | undefined;
p95_ms?: number | undefined;
p99_ms?: number | undefined;
}>;
throughput: z.ZodObject<{
requests_per_second: z.ZodDefault<z.ZodNumber>;
tokens_per_second: z.ZodDefault<z.ZodNumber>;
concurrent_requests: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
requests_per_second: number;
tokens_per_second: number;
concurrent_requests: number;
}, {
requests_per_second?: number | undefined;
tokens_per_second?: number | undefined;
concurrent_requests?: number | undefined;
}>;
optimization: z.ZodObject<{
token_savings_percent: z.ZodDefault<z.ZodNumber>;
cache_hit_rate: z.ZodDefault<z.ZodNumber>;
compression_ratio: z.ZodDefault<z.ZodNumber>;
parallel_efficiency: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
compression_ratio: number;
token_savings_percent: number;
cache_hit_rate: number;
parallel_efficiency: number;
}, {
compression_ratio?: number | undefined;
token_savings_percent?: number | undefined;
cache_hit_rate?: number | undefined;
parallel_efficiency?: number | undefined;
}>;
errors: z.ZodObject<{
timeout_rate: z.ZodDefault<z.ZodNumber>;
error_rate: z.ZodDefault<z.ZodNumber>;
retry_rate: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
timeout_rate: number;
error_rate: number;
retry_rate: number;
}, {
timeout_rate?: number | undefined;
error_rate?: number | undefined;
retry_rate?: number | undefined;
}>;
resource_usage: z.ZodObject<{
memory_usage_mb: z.ZodDefault<z.ZodNumber>;
cpu_usage_percent: z.ZodDefault<z.ZodNumber>;
network_usage_mb: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
memory_usage_mb: number;
cpu_usage_percent: number;
network_usage_mb: number;
}, {
memory_usage_mb?: number | undefined;
cpu_usage_percent?: number | undefined;
network_usage_mb?: number | undefined;
}>;
last_updated: z.ZodDate;
}, "strip", z.ZodTypeAny, {
response_times: {
avg_ms: number;
p50_ms: number;
p95_ms: number;
p99_ms: number;
};
throughput: {
requests_per_second: number;
tokens_per_second: number;
concurrent_requests: number;
};
optimization: {
compression_ratio: number;
token_savings_percent: number;
cache_hit_rate: number;
parallel_efficiency: number;
};
errors: {
timeout_rate: number;
error_rate: number;
retry_rate: number;
};
resource_usage: {
memory_usage_mb: number;
cpu_usage_percent: number;
network_usage_mb: number;
};
last_updated: Date;
}, {
response_times: {
avg_ms?: number | undefined;
p50_ms?: number | undefined;
p95_ms?: number | undefined;
p99_ms?: number | undefined;
};
throughput: {
requests_per_second?: number | undefined;
tokens_per_second?: number | undefined;
concurrent_requests?: number | undefined;
};
optimization: {
compression_ratio?: number | undefined;
token_savings_percent?: number | undefined;
cache_hit_rate?: number | undefined;
parallel_efficiency?: number | undefined;
};
errors: {
timeout_rate?: number | undefined;
error_rate?: number | undefined;
retry_rate?: number | undefined;
};
resource_usage: {
memory_usage_mb?: number | undefined;
cpu_usage_percent?: number | undefined;
network_usage_mb?: number | undefined;
};
last_updated: Date;
}>;
export type PerformanceMetrics = z.infer<typeof PerformanceMetricsSchema>;
export declare const ProcessingTaskSchema: z.ZodObject<{
id: z.ZodString;
type: z.ZodEnum<["embedding", "search", "prp_generation", "context_assembly"]>;
priority: z.ZodDefault<z.ZodEnum<["low", "normal", "high", "critical"]>>;
input_data: z.ZodAny;
context: z.ZodObject<{
workspace_id: z.ZodOptional<z.ZodString>;
project_id: z.ZodOptional<z.ZodString>;
agent_type: z.ZodOptional<z.ZodString>;
user_id: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
workspace_id?: string | undefined;
project_id?: string | undefined;
agent_type?: string | undefined;
user_id?: string | undefined;
}, {
workspace_id?: string | undefined;
project_id?: string | undefined;
agent_type?: string | undefined;
user_id?: string | undefined;
}>;
max_response_time_ms: z.ZodDefault<z.ZodNumber>;
token_budget: z.ZodOptional<z.ZodNumber>;
quality_threshold: z.ZodDefault<z.ZodNumber>;
created_at: z.ZodDate;
started_at: z.ZodOptional<z.ZodDate>;
completed_at: z.ZodOptional<z.ZodDate>;
status: z.ZodDefault<z.ZodEnum<["pending", "processing", "completed", "failed", "timeout"]>>;
error_message: z.ZodOptional<z.ZodString>;
retry_count: z.ZodDefault<z.ZodNumber>;
result: z.ZodOptional<z.ZodAny>;
performance_stats: z.ZodOptional<z.ZodObject<{
processing_time_ms: z.ZodNumber;
token_usage: z.ZodNumber;
cache_used: z.ZodBoolean;
optimization_applied: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
processing_time_ms: number;
token_usage: number;
cache_used: boolean;
optimization_applied: string[];
}, {
processing_time_ms: number;
token_usage: number;
cache_used: boolean;
optimization_applied: string[];
}>>;
}, "strip", z.ZodTypeAny, {
type: "embedding" | "search" | "prp_generation" | "context_assembly";
status: "completed" | "timeout" | "pending" | "processing" | "failed";
id: string;
created_at: Date;
priority: "low" | "high" | "critical" | "normal";
context: {
workspace_id?: string | undefined;
project_id?: string | undefined;
agent_type?: string | undefined;
user_id?: string | undefined;
};
max_response_time_ms: number;
quality_threshold: number;
retry_count: number;
input_data?: any;
token_budget?: number | undefined;
started_at?: Date | undefined;
completed_at?: Date | undefined;
error_message?: string | undefined;
result?: any;
performance_stats?: {
processing_time_ms: number;
token_usage: number;
cache_used: boolean;
optimization_applied: string[];
} | undefined;
}, {
type: "embedding" | "search" | "prp_generation" | "context_assembly";
id: string;
created_at: Date;
context: {
workspace_id?: string | undefined;
project_id?: string | undefined;
agent_type?: string | undefined;
user_id?: string | undefined;
};
status?: "completed" | "timeout" | "pending" | "processing" | "failed" | undefined;
priority?: "low" | "high" | "critical" | "normal" | undefined;
input_data?: any;
max_response_time_ms?: number | undefined;
token_budget?: number | undefined;
quality_threshold?: number | undefined;
started_at?: Date | undefined;
completed_at?: Date | undefined;
error_message?: string | undefined;
retry_count?: number | undefined;
result?: any;
performance_stats?: {
processing_time_ms: number;
token_usage: number;
cache_used: boolean;
optimization_applied: string[];
} | undefined;
}>;
export type ProcessingTask = z.infer<typeof ProcessingTaskSchema>;
/**
* Advanced Performance Optimizer
*/
export declare class PerformanceOptimizer {
private config;
private metrics;
private taskQueue;
private processingTasks;
private responseTimes;
private metricsInterval?;
constructor(config?: Partial<PerformanceConfig>);
/**
* Process tasks with intelligent optimization
*/
processTask<T>(task: Omit<ProcessingTask, 'id' | 'created_at' | 'status'>, processor: (task: ProcessingTask) => Promise<T>): Promise<{
result: T;
performance: ProcessingTask['performance_stats'];
}>;
/**
* Batch process multiple tasks with intelligent optimization
*/
processBatch<T>(tasks: Array<Omit<ProcessingTask, 'id' | 'created_at' | 'status'>>, processor: (task: ProcessingTask) => Promise<T>): Promise<Array<{
result: T;
performance: ProcessingTask['performance_stats'];
}>>;
/**
* Optimize content for token efficiency
*/
optimizeContent(content: string, options?: {
target_length?: number;
preserve_structure?: boolean;
compression_level?: 'none' | 'basic' | 'aggressive';
}): Promise<{
optimized_content: string;
compression_ratio: number;
token_reduction: number;
}>;
/**
* Progressive query refinement with fallback strategies
*/
refineQuery(originalQuery: string, context: any, previousResults?: any[]): Promise<{
refined_query: string;
strategy_used: string;
confidence: number;
}>;
/**
* Basic content optimization
*/
private basicContentOptimization;
/**
* Aggressive content optimization
*/
private aggressiveContentOptimization;
/**
* Extract important sentences based on keyword density
*/
private extractImportantSentences;
/**
* Calculate sentence importance score
*/
private calculateSentenceImportance;
/**
* Compress text to key keywords and phrases
*/
private compressToKeywords;
/**
* Extract keywords from text
*/
private extractKeywords;
/**
* Refine query with context information
*/
private refineWithContext;
/**
* Simplify complex queries
*/
private simplifyQuery;
/**
* Refine query based on previous results
*/
private refineFromResults;
/**
* Check cache for existing results
*/
private checkCache;
/**
* Cache processing result
*/
private cacheResult;
/**
* Generate cache key for task
*/
private generateCacheKey;
/**
* Optimize task before processing
*/
private optimizeTask;
/**
* Optimize object content recursively
*/
private optimizeObjectContent;
/**
* Execute task with performance monitoring
*/
private executeWithOptimization;
/**
* Generate unique task ID
*/
private generateTaskId;
/**
* Estimate token usage for result
*/
private estimateTokenUsage;
/**
* Get applied optimizations for task
*/
private getAppliedOptimizations;
/**
* Update performance metrics
*/
private updateMetrics;
/**
* Update error metrics
*/
private updateErrorMetrics;
/**
* Start metrics collection
*/
private startMetricsCollection;
/**
* Get current performance metrics
*/
getMetrics(): PerformanceMetrics;
/**
* Get current task queue status
*/
getTaskQueueStatus(): {
pending: number;
processing: number;
total_capacity: number;
};
/**
* Shutdown performance optimizer
*/
shutdown(): void;
}
export declare const performanceOptimizer: PerformanceOptimizer;