@spaik/mcp-server-roi/dist/services/ml-comparison-engine.d.ts

MCP server for AI ROI prediction and tracking with Monte Carlo simulations

import { z } from 'zod';
import { Projection } from '../schemas/projection.js';
import { UseCase } from '../schemas/use-case.js';
export declare const ProjectFeaturesSchema: z.ZodObject<{
    totalInvestment: z.ZodNumber;
    expectedROI: z.ZodNumber;
    paybackPeriodMonths: z.ZodNumber;
    netPresentValue: z.ZodNumber;
    useCaseCount: z.ZodNumber;
    timelineMonths: z.ZodNumber;
    implementationComplexity: z.ZodNumber;
    industry: z.ZodString;
    companySize: z.ZodEnum<["small", "medium", "large", "enterprise"]>;
    technicalRisk: z.ZodNumber;
    organizationalRisk: z.ZodNumber;
    marketRisk: z.ZodNumber;
    similarProjectSuccessRate: z.ZodOptional<z.ZodNumber>;
    industryAverageROI: z.ZodOptional<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    industry: string;
    totalInvestment: number;
    expectedROI: number;
    paybackPeriodMonths: number;
    netPresentValue: number;
    useCaseCount: number;
    timelineMonths: number;
    implementationComplexity: number;
    companySize: "medium" | "small" | "large" | "enterprise";
    technicalRisk: number;
    organizationalRisk: number;
    marketRisk: number;
    similarProjectSuccessRate?: number | undefined;
    industryAverageROI?: number | undefined;
}, {
    industry: string;
    totalInvestment: number;
    expectedROI: number;
    paybackPeriodMonths: number;
    netPresentValue: number;
    useCaseCount: number;
    timelineMonths: number;
    implementationComplexity: number;
    companySize: "medium" | "small" | "large" | "enterprise";
    technicalRisk: number;
    organizationalRisk: number;
    marketRisk: number;
    similarProjectSuccessRate?: number | undefined;
    industryAverageROI?: number | undefined;
}>;
export type ProjectFeatures = z.infer<typeof ProjectFeaturesSchema>;
export declare const MLPredictionSchema: z.ZodObject<{
    successProbability: z.ZodNumber;
    confidenceInterval: z.ZodObject<{
        lower: z.ZodNumber;
        upper: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        lower: number;
        upper: number;
    }, {
        lower: number;
        upper: number;
    }>;
    riskScore: z.ZodNumber;
    predictedActualROI: z.ZodNumber;
    predictedDelayMonths: z.ZodNumber;
    keyRiskFactors: z.ZodArray<z.ZodObject<{
        factor: z.ZodString;
        impact: z.ZodEnum<["low", "medium", "high"]>;
        mitigation: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        impact: "low" | "medium" | "high";
        factor: string;
        mitigation: string;
    }, {
        impact: "low" | "medium" | "high";
        factor: string;
        mitigation: string;
    }>, "many">;
    synergies: z.ZodOptional<z.ZodArray<z.ZodObject<{
        withProject: z.ZodString;
        type: z.ZodString;
        estimatedValue: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        type: string;
        withProject: string;
        estimatedValue: number;
    }, {
        type: string;
        withProject: string;
        estimatedValue: number;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    successProbability: number;
    confidenceInterval: {
        lower: number;
        upper: number;
    };
    riskScore: number;
    predictedActualROI: number;
    predictedDelayMonths: number;
    keyRiskFactors: {
        impact: "low" | "medium" | "high";
        factor: string;
        mitigation: string;
    }[];
    synergies?: {
        type: string;
        withProject: string;
        estimatedValue: number;
    }[] | undefined;
}, {
    successProbability: number;
    confidenceInterval: {
        lower: number;
        upper: number;
    };
    riskScore: number;
    predictedActualROI: number;
    predictedDelayMonths: number;
    keyRiskFactors: {
        impact: "low" | "medium" | "high";
        factor: string;
        mitigation: string;
    }[];
    synergies?: {
        type: string;
        withProject: string;
        estimatedValue: number;
    }[] | undefined;
}>;
export type MLPrediction = z.infer<typeof MLPredictionSchema>;
export declare const MLComparisonResultSchema: z.ZodObject<{
    projectId: z.ZodString;
    baseMetrics: z.ZodObject<{
        roi: z.ZodNumber;
        paybackPeriod: z.ZodNumber;
        npv: z.ZodNumber;
        totalInvestment: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        roi: number;
        npv: number;
        totalInvestment: number;
        paybackPeriod: number;
    }, {
        roi: number;
        npv: number;
        totalInvestment: number;
        paybackPeriod: number;
    }>;
    mlPredictions: z.ZodObject<{
        successProbability: z.ZodNumber;
        confidenceInterval: z.ZodObject<{
            lower: z.ZodNumber;
            upper: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            lower: number;
            upper: number;
        }, {
            lower: number;
            upper: number;
        }>;
        riskScore: z.ZodNumber;
        predictedActualROI: z.ZodNumber;
        predictedDelayMonths: z.ZodNumber;
        keyRiskFactors: z.ZodArray<z.ZodObject<{
            factor: z.ZodString;
            impact: z.ZodEnum<["low", "medium", "high"]>;
            mitigation: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            impact: "low" | "medium" | "high";
            factor: string;
            mitigation: string;
        }, {
            impact: "low" | "medium" | "high";
            factor: string;
            mitigation: string;
        }>, "many">;
        synergies: z.ZodOptional<z.ZodArray<z.ZodObject<{
            withProject: z.ZodString;
            type: z.ZodString;
            estimatedValue: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            type: string;
            withProject: string;
            estimatedValue: number;
        }, {
            type: string;
            withProject: string;
            estimatedValue: number;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        successProbability: number;
        confidenceInterval: {
            lower: number;
            upper: number;
        };
        riskScore: number;
        predictedActualROI: number;
        predictedDelayMonths: number;
        keyRiskFactors: {
            impact: "low" | "medium" | "high";
            factor: string;
            mitigation: string;
        }[];
        synergies?: {
            type: string;
            withProject: string;
            estimatedValue: number;
        }[] | undefined;
    }, {
        successProbability: number;
        confidenceInterval: {
            lower: number;
            upper: number;
        };
        riskScore: number;
        predictedActualROI: number;
        predictedDelayMonths: number;
        keyRiskFactors: {
            impact: "low" | "medium" | "high";
            factor: string;
            mitigation: string;
        }[];
        synergies?: {
            type: string;
            withProject: string;
            estimatedValue: number;
        }[] | undefined;
    }>;
    ranking: z.ZodObject<{
        overall: z.ZodNumber;
        byROI: z.ZodNumber;
        byRisk: z.ZodNumber;
        bySpeed: z.ZodNumber;
    }, "strip", z.ZodTypeAny, {
        overall: number;
        byROI: number;
        byRisk: number;
        bySpeed: number;
    }, {
        overall: number;
        byROI: number;
        byRisk: number;
        bySpeed: number;
    }>;
    recommendation: z.ZodEnum<["strongly_recommend", "recommend", "consider", "reconsider", "not_recommended"]>;
    insights: z.ZodArray<z.ZodString, "many">;
}, "strip", z.ZodTypeAny, {
    insights: string[];
    projectId: string;
    baseMetrics: {
        roi: number;
        npv: number;
        totalInvestment: number;
        paybackPeriod: number;
    };
    mlPredictions: {
        successProbability: number;
        confidenceInterval: {
            lower: number;
            upper: number;
        };
        riskScore: number;
        predictedActualROI: number;
        predictedDelayMonths: number;
        keyRiskFactors: {
            impact: "low" | "medium" | "high";
            factor: string;
            mitigation: string;
        }[];
        synergies?: {
            type: string;
            withProject: string;
            estimatedValue: number;
        }[] | undefined;
    };
    ranking: {
        overall: number;
        byROI: number;
        byRisk: number;
        bySpeed: number;
    };
    recommendation: "strongly_recommend" | "recommend" | "consider" | "reconsider" | "not_recommended";
}, {
    insights: string[];
    projectId: string;
    baseMetrics: {
        roi: number;
        npv: number;
        totalInvestment: number;
        paybackPeriod: number;
    };
    mlPredictions: {
        successProbability: number;
        confidenceInterval: {
            lower: number;
            upper: number;
        };
        riskScore: number;
        predictedActualROI: number;
        predictedDelayMonths: number;
        keyRiskFactors: {
            impact: "low" | "medium" | "high";
            factor: string;
            mitigation: string;
        }[];
        synergies?: {
            type: string;
            withProject: string;
            estimatedValue: number;
        }[] | undefined;
    };
    ranking: {
        overall: number;
        byROI: number;
        byRisk: number;
        bySpeed: number;
    };
    recommendation: "strongly_recommend" | "recommend" | "consider" | "reconsider" | "not_recommended";
}>;
export type MLComparisonResult = z.infer<typeof MLComparisonResultSchema>;
/**
 * Machine Learning engine for advanced project comparison
 * Uses ensemble methods for robust predictions
 */
export declare class MLComparisonEngine {
    private logger;
    private forests;
    private readonly treeCount;
    private readonly maxDepth;
    constructor();
    /**
     * Extract features from project data for ML processing
     */
    extractFeatures(projection: Projection, useCases: UseCase[], industry: string, companySize?: string): ProjectFeatures;
    /**
     * Generate ML predictions for a project
     */
    predict(features: ProjectFeatures): Promise<MLPrediction>;
    /**
     * Compare multiple projects with ML insights
     */
    compareProjects(projects: Array<{
        id: string;
        projection: Projection;
        useCases: UseCase[];
        industry: string;
        companySize?: string;
    }>): Promise<MLComparisonResult[]>;
    /**
     * Calculate complexity score based on use cases
     */
    private calculateComplexityScore;
    /**
     * Assess risk factors
     */
    private assessRiskFactors;
    /**
     * Calculate overall risk score
     */
    private calculateRiskScore;
    /**
     * Predict ROI adjustment factor based on ML model
     */
    private predictROIAdjustment;
    /**
     * Predict project delays
     */
    private predictDelays;
    /**
     * Identify key risk factors
     */
    private identifyKeyRisks;
    /**
     * Detect synergies between projects
     */
    private detectSynergies;
    /**
     * Rank projects by multiple criteria
     */
    private rankProjects;
    /**
     * Generate recommendation based on predictions and rankings
     */
    private generateRecommendation;
    /**
     * Generate human-readable insights
     */
    private generateInsights;
    /**
     * Initialize Random Forest (simplified implementation)
     */
    private initializeForests;
    private mean;
    private standardDeviation;
    private getHistoricalSuccessRate;
    private getIndustryAverageROI;
}
//# sourceMappingURL=ml-comparison-engine.d.ts.map