@gork-labs/secondbrain-mcp/dist/ml/ml-engine.d.ts

Second Brain MCP Server - Agent team orchestration with dynamic tool discovery

/**
 * Machine Learning Engine for SecondBrain MCP
 *
 * Provides adaptive intelligence with ensemble methods and auto-optimization:
 * - Ensemble predictions using multiple specialized models
 * - A/B testing framework for continuous experimentation
 * - Auto-optimization for parameter tuning and adaptation
 * - Meta-learning capabilities for improved learning effectiveness
 * - Predictive quality scoring and analytics (Phase 7 foundation)
 *
 * Author: @bohdan-shulha
 * Created: 2025-07-24T23:19:59+02:00
 * Phase: 8 - Ensemble Methods & Auto-Optimization (Adaptive Intelligence)
 */
import { AnalyticsManager } from '../analytics/analytics-manager.js';
import { EnhancedQualityAssessment, ValidationContext, MLPrediction, MLInsight, PredictiveAnalytics } from '../utils/types.js';
export interface MLEngineConfig {
    enabled: boolean;
    modelUpdateInterval: number;
    minTrainingDataPoints: number;
    predictionConfidenceThreshold: number;
    adaptiveThresholdsEnabled: boolean;
    autoOptimizationEnabled: boolean;
}
export interface PredictiveScoring {
    predictedScore: number;
    confidence: number;
    predictionBasis: string[];
    riskFactors: string[];
    successFactors: string[];
}
export interface OptimizationSuggestion {
    type: 'threshold' | 'rule_weight' | 'refinement_strategy';
    component: string;
    currentValue: number;
    suggestedValue: number;
    expectedImprovement: number;
    confidence: number;
    rationale: string;
}
export interface LearningPattern {
    pattern: string;
    frequency: number;
    successRate: number;
    contextFactors: string[];
    recommendedActions: string[];
    confidence: number;
}
export declare class MLEngine {
    private analyticsManager;
    private config;
    private models;
    private trainingData;
    private lastModelUpdate;
    private learningPatterns;
    private optimizationHistory;
    constructor(analyticsManager: AnalyticsManager, config?: Partial<MLEngineConfig>);
    /**
     * Initialize ML models for different prediction tasks
     */
    private initializeModels;
    /**
     * Predict quality score for a given context before actual validation
     */
    predictQualityScore(context: ValidationContext): Promise<PredictiveScoring>;
    /**
     * Predict refinement success probability
     */
    predictRefinementSuccess(currentScore: number, context: ValidationContext, refinementAttempt: number): Promise<MLPrediction>;
    /**
     * Generate optimization suggestions based on ML analysis
     */
    generateOptimizationSuggestions(): Promise<OptimizationSuggestion[]>;
    /**
     * Learn from validation results to improve predictions
     */
    learnFromValidation(context: ValidationContext, assessment: EnhancedQualityAssessment, prediction?: PredictiveScoring): Promise<void>;
    /**
     * Get machine learning insights about system performance
     */
    getMLInsights(): Promise<MLInsight[]>;
    /**
     * Phase 7: Advanced Predictive Analytics
     * Generate comprehensive predictive analytics with forecasting and anomaly detection
     */
    generatePredictiveAnalytics(): Promise<PredictiveAnalytics>;
    /**
     * Generate quality forecast using time series analysis
     */
    private generateQualityForecast;
    /**
     * Detect anomalies in system behavior using statistical methods
     */
    private detectAnomalies;
    /**
     * Analyze patterns across different chatmodes for correlations
     */
    private analyzeCrossChatmodePatterns;
    /**
     * Generate proactive alerts based on detected patterns and anomalies
     */
    private generateProactiveAlerts;
    /**
     * Extract features from validation context for ML models
     */
    private extractFeatures;
    /**
     * Calculate content complexity based on technical terms and concepts
     */
    private calculateContentComplexity;
    /**
     * Run inference using a trained model
     */
    private runInference;
    /**
     * Calculate prediction confidence based on model and features
     */
    private calculatePredictionConfidence;
    /**
     * Encode chatmode as numeric value for ML models
     */
    private encodeChatmode;
    /**
     * Get quality threshold for a specific chatmode
     */
    private getQualityThreshold;
    /**
     * Generate fallback prediction when ML is unavailable
     */
    private fallbackPrediction;
    /**
     * Identify risk factors that might lead to poor quality
     */
    private identifyRiskFactors;
    /**
     * Identify success factors that might lead to high quality
     */
    private identifySuccessFactors;
    /**
     * Additional helper methods for ML operations
     */
    private calculateTrend;
    private analyzeIssueTypes;
    private getPreviousRefinementSuccess;
    private analyzeThresholdOptimization;
    private analyzeRuleWeightOptimization;
    private analyzeRefinementStrategyOptimization;
    private updateLearningPatterns;
    private shouldRetrain;
    private retrainModels;
    /**
     * Get ML engine status and health
    /**
     * Get ML engine status and health
     */
    getMLStatus(): {
        enabled: boolean;
        modelsLoaded: number;
        trainingDataSize: number;
        lastModelUpdate: number;
        learningPatternsCount: number;
        optimizationHistorySize: number;
        modelAccuracies: {
            [k: string]: number;
        };
        phase: string;
        capabilities: string[];
    };
    /**
     * Helper methods for ML optimization and learning
     */
    private calculateVariance;
    private calculateOptimalThreshold;
    private estimateRuleScore;
    private calculateCorrelation;
    private updateContextFactors;
    private updateRecommendedActions;
    private extractFailurePatterns;
    private extractSuccessPatterns;
    /**
     * Generate model-specific recommendations based on performance
     */
    private generateModelRecommendation;
    /**
     * Format pattern names for better readability
     */
    private formatPatternName;
    /**
     * Analyze training data distribution across chatmodes
     */
    private analyzeDataDistribution;
    /**
     * Generate real-time adaptation insights
     */
    private generateAdaptationInsights;
    /**
     * Calculate model drift score based on recent vs historical performance
     */
    private calculateModelDrift;
    /**
     * Identify optimization opportunities based on patterns and performance
     */
    private identifyOptimizationOpportunities;
    /**
     * Phase 7 Helper Methods for Advanced Predictive Analytics
     */
    /**
     * Calculate linear trend using least squares regression
     */
    private calculateLinearTrend;
    /**
     * Detect anomalies using z-score method
     */
    private detectZScoreAnomalies;
    /**
     * Detect pattern-based anomalies
     */
    private detectPatternAnomalies;
    /**
     * Calculate correlation between two chatmodes
     */
    private calculateChatmodeCorrelation;
    /**
     * Analyze processing time patterns across chatmodes
     */
    private analyzeProcessingTimePatterns;
    /**
     * Analyze success rate patterns across chatmodes
     */
    private analyzeSuccessRatePatterns;
    /**
     * Analyze performance trend for degradation detection
     */
    private analyzePerformanceTrend;
    /**
     * Analyze quality trend for decline detection
     */
    private analyzeQualityTrend;
    /**
     * Detect trend reversals in chatmode performance
     */
    private detectTrendReversals;
    /**
     * Generate ensemble prediction using multiple specialized models
     */
    generateEnsemblePrediction(context: ValidationContext): Promise<import('../utils/types.js').EnsemblePrediction>;
    /**
     * Configure and start A/B test experiment
     */
    configureABTest(config: import('../utils/types.js').ABTestConfig): Promise<boolean>;
    /**
     * Evaluate A/B test results and provide recommendations
     */
    evaluateABTestResults(experimentId: string): Promise<import('../utils/types.js').ABTestResult>;
    /**
     * Run auto-optimization for specified parameters
     */
    runAutoOptimization(config: import('../utils/types.js').AutoOptimizationConfig): Promise<import('../utils/types.js').OptimizationResult>;
    /**
     * Generate meta-learning insights about learning effectiveness
     */
    generateMetaLearningInsights(): Promise<import('../utils/types.js').MetaLearningInsight[]>;
    /**
     * Get comprehensive adaptive intelligence status
     */
    getAdaptiveIntelligence(): Promise<import('../utils/types.js').AdaptiveIntelligence>;
    private initializeEnsembleModels;
    private getStatisticalModelPrediction;
    private getPatternRecognitionPrediction;
    private getDomainSpecificPrediction;
    private getMetaLearningPrediction;
    private calculateEnsembleVote;
    private validateEnsemblePrediction;
    private findSimilarCases;
    private assessCurrentLearningEffectiveness;
    private calculateAccuracyTrend;
    private validateABTestConfig;
    private findConflictingExperiments;
    private initializeExperimentTracking;
    private configureTrafficAllocation;
    private startSafetyMonitoring;
    private getExperimentData;
    private calculateStatisticalSignificance;
    private identifyWinningVariant;
    private generateExperimentInsights;
    private generateExperimentRecommendation;
    private getExperimentStatus;
    private calculateExperimentDuration;
    private calculateStatisticalPower;
    private initializeOptimizer;
    private evaluateParametersSafely;
    private checkSafetyConstraints;
    private hasConverged;
    private determineOptimizationStatus;
    private getSafetyMetrics;
    private analyzeLearningEfficiency;
    private identifyTransferOpportunities;
    private optimizeLearningCurriculum;
    private analyzeFeatureImportance;
    private analyzeModelCombinations;
    private calculateChatmodeSimilarity;
    private getRecentEnsemblePredictions;
    private getActiveExperiments;
    private getRecentExperimentResults;
    private getRecentOptimizationResults;
    private getRecentSystemAdaptations;
}