@codai/memorai-mcp/dist/predictive-engine.d.ts

MemorAI CBD-based MCP Server - High-Performance Vector Memory System

/**
 * Phase 3: AI-Powered Memory Intelligence - Predictive Memory Engine
 *
 * Revolutionary predictive capabilities that set new industry standards:
 * - Predicts what memories users will need before they search
 * - Optimizes memory creation timing
 * - Forecasts relationship formation and importance evolution
 * - Provides proactive memory management suggestions
 */
import OpenAI from 'openai';
import { AdvancedMemory } from './server.js';
export interface PredictedMemory {
    memoryId: string;
    title: string;
    content: string;
    predictedRelevance: number;
    reasoning: string;
    suggestedActions: string[];
    confidence: number;
    timeToNeed: number;
}
export interface OptimalTiming {
    recommendedTime: string;
    reasoning: string;
    confidence: number;
    factors: TimingFactor[];
}
export interface TimingFactor {
    factor: string;
    impact: number;
    description: string;
}
export interface PredictedRelationship {
    sourceMemoryId: string;
    targetMemoryId: string;
    relationshipType: 'related' | 'references' | 'follows' | 'contradicts' | 'updates' | 'similar' | 'contains' | 'explains';
    strength: number;
    formationProbability: number;
    timeToFormation: number;
    reasoning: string;
}
export interface ImportanceForecast {
    memoryId: string;
    currentImportance: number;
    predictedImportance: number[];
    timePoints: string[];
    trendDirection: 'increasing' | 'decreasing' | 'stable' | 'volatile';
    confidenceInterval: {
        min: number;
        max: number;
    }[];
    factors: ImportanceDriver[];
}
export interface ImportanceDriver {
    factor: string;
    impact: number;
    description: string;
    confidence: number;
}
export interface PredictionContext {
    currentTask?: string;
    timeOfDay: string;
    recentActivity: Activity[];
    upcomingEvents: Event[];
    workingMemory: string[];
    userBehaviorPattern?: UserPattern;
    environmentalFactors?: EnvironmentalContext;
}
export interface Activity {
    type: 'search' | 'create' | 'update' | 'link' | 'view';
    timestamp: string;
    memoryIds: string[];
    query?: string;
    success: boolean;
    duration: number;
}
export interface Event {
    id: string;
    title: string;
    startTime: string;
    endTime: string;
    participants?: string[];
    relatedMemories?: string[];
    priority: 'low' | 'medium' | 'high' | 'critical';
}
export interface UserPattern {
    peakHours: string[];
    preferredMemoryTypes: string[];
    searchPatterns: string[];
    collaborationStyle: 'individual' | 'team' | 'mixed';
    learningStyle: 'visual' | 'textual' | 'structured' | 'exploratory';
}
export interface EnvironmentalContext {
    currentProject: string;
    teamSize: number;
    deadline?: string;
    workload: 'light' | 'moderate' | 'heavy' | 'critical';
    interruptionLevel: 'low' | 'medium' | 'high';
}
export interface PredictionHistory {
    predictionId: string;
    timestamp: string;
    type: 'memory_need' | 'timing' | 'relationship' | 'importance';
    prediction: any;
    actualOutcome?: any;
    accuracy?: number;
    feedback?: string;
}
export declare class PredictiveMemoryEngine {
    private openaiClient?;
    private memories;
    private predictionHistory;
    private userPatterns;
    private predictionCache;
    private cacheTimeout;
    constructor(openaiClient?: OpenAI, memories?: Map<string, AdvancedMemory>);
    /**
     * Predict what memories user will need before they search
     * Revolutionary proactive memory suggestions
     */
    predictNeededMemories(agentId: string, context: PredictionContext): Promise<PredictedMemory[]>;
    /**
     * Predict optimal memory creation timing
     * Smart timing recommendations based on context and patterns
     */
    predictMemoryCreationTiming(agentId: string, contentType: string, context?: PredictionContext): Promise<OptimalTiming>;
    /**
     * Predict memory relationship formation
     * Forecast future connections between memories
     */
    predictFutureRelationships(memoryId: string, timeHorizon?: number): Promise<PredictedRelationship[]>;
    /**
     * Predict memory importance evolution
     * Forecast how memory importance will change over time
     */
    predictImportanceChanges(memoryId: string, timeHorizon?: number): Promise<ImportanceForecast>;
    private getCachedPrediction;
    private cachePrediction;
    private analyzeUserPattern;
    private extractUserPatternFromMemories;
    private updatePatternWithContext;
    private scoreMemoriesByPredictedNeed;
    private calculateNeedScore;
    private calculateTimeBasedScore;
    private calculateContextScore;
    private calculatePatternScore;
    private estimateTimeToNeed;
    private generateAIPredictions;
    private buildPredictionPrompt;
    private parseAIPredictions;
    private combineAndRankPredictions;
    private analyzeWorkloadTiming;
    private analyzeTimeOfDayOptimal;
    private analyzeMemoryTypeTiming;
    private calculateOptimalTiming;
    private generateTimingReasoning;
    private hasExistingRelationship;
    private predictRelationshipFormation;
    private calculateContentSimilarity;
    private calculateTemporalProximity;
    private calculateContextAlignment;
    private predictRelationshipType;
    private calculateFormationProbability;
    private estimateFormationTime;
    private generateRelationshipReasoning;
    private analyzeImportanceDrivers;
    private getEntityTypeImportance;
    private generateTimePoints;
    private forecastImportanceTrajectory;
    private determineTrendDirection;
    private calculateConfidenceIntervals;
    private extractTitle;
    /**
     * Record prediction accuracy for continuous learning
     */
    recordPredictionOutcome(predictionId: string, actualOutcome: any, accuracy: number, feedback?: string): Promise<void>;
    /**
     * Get prediction accuracy statistics
     */
    getPredictionStats(): {
        totalPredictions: number;
        averageAccuracy: number;
        accuracyByType: Record<string, number>;
    };
}
//# sourceMappingURL=predictive-engine.d.ts.map