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

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

/**
 * Phase 4.1: Enhanced Predictive Memory Engine
 *
 * Next-generation predictive capabilities building on Phase 3 foundation:
 * - Advanced learning from usage patterns
 * - Real-time adaptation based on effectiveness metrics
 * - Enhanced prediction accuracy through continuous learning
 * - Sophisticated context understanding and pattern recognition
 * - Cross-agent prediction sharing and collaboration
 */
import OpenAI from 'openai';
import { AdvancedMemory } from './server.js';
import { MemoryUsagePattern } from './learning-engine.js';
export interface AdvancedPredictedMemory {
    memoryId: string;
    title: string;
    content: string;
    predictedRelevance: number;
    reasoning: string;
    suggestedActions: string[];
    confidence: number;
    timeToNeed: number;
    learningFactors: LearningFactor[];
    adaptationScore: number;
    collaborativeInsights?: CollaborativeInsight[];
}
export interface LearningFactor {
    type: 'usage_pattern' | 'timing_pattern' | 'context_pattern' | 'success_rate';
    description: string;
    strength: number;
    evidence: string[];
    adaptability: number;
}
export interface CollaborativeInsight {
    sourceAgentId: string;
    insightType: 'usage_pattern' | 'timing_optimization' | 'context_enhancement';
    description: string;
    relevanceScore: number;
    trustScore: number;
}
export interface EnhancedOptimalTiming {
    recommendedTime: string;
    reasoning: string;
    confidence: number;
    factors: TimingFactor[];
    learningAdaptations: LearningAdaptation[];
    realTimeAdjustments: RealTimeAdjustment[];
}
export interface LearningAdaptation {
    type: 'timing_shift' | 'frequency_adjustment' | 'context_awareness';
    description: string;
    impact: number;
    confidence: number;
    source: 'usage_analysis' | 'effectiveness_metrics' | 'collaborative_learning';
}
export interface RealTimeAdjustment {
    trigger: string;
    adjustment: string;
    impact: number;
    timestamp: string;
}
export interface TimingFactor {
    factor: string;
    impact: number;
    description: string;
}
export interface EvolutionPrediction {
    memoryId: string;
    currentState: MemoryState;
    predictedEvolution: EvolutionStep[];
    timeHorizon: string;
    confidence: number;
    triggerEvents: TriggerEvent[];
}
export interface MemoryState {
    importance: number;
    usageFrequency: number;
    contentQuality: number;
    relationshipCount: number;
    lastAccessTime: string;
}
export interface EvolutionStep {
    timeframe: string;
    expectedChanges: MemoryChange[];
    probability: number;
    catalysts: string[];
}
export interface MemoryChange {
    attribute: 'importance' | 'usage' | 'relationships' | 'content';
    direction: 'increase' | 'decrease' | 'stable';
    magnitude: number;
    reason: string;
}
export interface TriggerEvent {
    event: string;
    probability: number;
    impact: MemoryChange[];
    timeToEvent: number;
}
export interface OptimalStructurePrediction {
    agentId: string;
    currentStructure: MemoryStructureAnalysis;
    recommendedStructure: RecommendedStructure;
    migrationPlan: StructureMigrationPlan;
    expectedBenefits: StructureBenefit[];
    implementationComplexity: 'low' | 'medium' | 'high';
}
export interface MemoryStructureAnalysis {
    totalMemories: number;
    clusterCount: number;
    averageClusterSize: number;
    relationshipDensity: number;
    organizationScore: number;
    accessPatternEfficiency: number;
}
export interface RecommendedStructure {
    optimalClusterCount: number;
    clusterThemes: ClusterTheme[];
    relationshipOptimizations: RelationshipOptimization[];
    accessOptimizations: AccessOptimization[];
}
export interface ClusterTheme {
    name: string;
    description: string;
    expectedMemoryCount: number;
    primaryKeywords: string[];
    accessPatterns: string[];
}
export interface RelationshipOptimization {
    type: 'strengthen' | 'weaken' | 'create' | 'remove';
    sourceMemoryId: string;
    targetMemoryId: string;
    reasoning: string;
    expectedBenefit: string;
}
export interface AccessOptimization {
    optimization: string;
    description: string;
    expectedImpact: number;
    implementationEffort: 'low' | 'medium' | 'high';
}
export interface StructureMigrationPlan {
    phases: MigrationPhase[];
    totalDuration: string;
    riskAssessment: MigrationRisk[];
    rollbackStrategy: string;
}
export interface MigrationPhase {
    name: string;
    duration: string;
    actions: string[];
    dependencies: string[];
    successCriteria: string[];
}
export interface MigrationRisk {
    risk: string;
    probability: number;
    impact: number;
    mitigation: string;
}
export interface StructureBenefit {
    category: 'performance' | 'organization' | 'user_experience' | 'collaboration';
    description: string;
    quantifiableBenefit: string;
    timeToRealization: string;
}
export interface UsageLearningResult {
    agentId: string;
    learningPeriod: string;
    patternsLearned: LearnedPattern[];
    adaptationsMade: PredictionAdaptation[];
    performanceImprovements: PerformanceImprovement[];
    nextLearningCycle: string;
}
export interface LearnedPattern {
    type: 'temporal' | 'contextual' | 'behavioral' | 'collaborative';
    pattern: string;
    strength: number;
    applications: string[];
    validationScore: number;
}
export interface PredictionAdaptation {
    predictionType: 'memory_need' | 'timing' | 'structure' | 'evolution';
    originalApproach: string;
    adaptedApproach: string;
    improvementReason: string;
    measuredImprovement: number;
}
export interface PerformanceImprovement {
    metric: 'accuracy' | 'response_time' | 'user_satisfaction' | 'relevance';
    beforeValue: number;
    afterValue: number;
    improvementPercentage: number;
}
export interface PredictionContext {
    currentTask: string;
    recentMemories: string[];
    timeOfDay: string;
    urgency: 'low' | 'medium' | 'high' | 'critical';
    collaborators?: string[];
    projectContext?: string;
    userPreferences?: UserPreferences;
    environmentalContext?: EnvironmentalContext;
}
export interface UserPreferences {
    memoryTypes: string[];
    detailLevel: 'minimal' | 'moderate' | 'comprehensive';
    learningStyle: 'visual' | 'textual' | 'structured' | 'exploratory';
}
export interface EnvironmentalContext {
    currentProject: string;
    teamSize: number;
    deadline?: string;
    workload: 'light' | 'moderate' | 'heavy' | 'critical';
    interruptionLevel: 'low' | 'medium' | 'high';
}
export declare class EnhancedPredictiveMemoryEngine {
    private openaiClient?;
    private memories;
    private learningEngine;
    private predictionHistory;
    private usagePatterns;
    private learningInsights;
    private predictionCache;
    private cacheTimeout;
    constructor(openaiClient?: OpenAI, memories?: Map<string, AdvancedMemory>);
    /**
     * Enhanced memory need prediction with learning integration
     * Uses real-time learning to continuously improve accuracy
     */
    predictNeededMemoriesEnhanced(agentId: string, context: PredictionContext): Promise<AdvancedPredictedMemory[]>;
    /**
     * Predict optimal memory structure based on usage patterns and learning
     * Revolutionary structural optimization using AI and machine learning
     */
    predictOptimalStructure(agentId: string): Promise<OptimalStructurePrediction>;
    /**
     * Predict memory evolution with learning-enhanced accuracy
     * Uses continuous learning to improve evolution predictions
     */
    predictMemoryEvolution(memoryId: string, timeHorizon?: string): Promise<EvolutionPrediction>;
    /**
     * Learn from usage patterns to improve future predictions
     * Continuous learning system for predictive accuracy enhancement
     */
    learnFromUsagePatterns(agentId: string, usagePatterns: MemoryUsagePattern[]): Promise<UsageLearningResult>;
    private generateBasePredictions;
    private enhancePredictionsWithLearning;
    private addCollaborativeInsights;
    private analyzeCurrentStructure;
    private generateStructureRecommendations;
    private createStructureMigrationPlan;
    private calculateStructureBenefits;
    private assessImplementationComplexity;
    private analyzeMemoryState;
    private generateEvolutionSteps;
    private identifyTriggerEvents;
    private calculateEvolutionConfidence;
    private extractLearnedPatterns;
    private adaptPredictionAlgorithms;
    private measurePerformanceImprovements;
    private scheduleNextLearningCycle;
    private calculateContextualRelevance;
    private estimateTimeToNeed;
    private getCachedPrediction;
    private setCachedPrediction;
}
//# sourceMappingURL=enhanced-predictive-engine.d.ts.map