@codai/memorai-core/dist/ai/DeepLearningMemoryEngine.d.ts

Simplified advanced memory engine - no tiers, just powerful semantic search with persistence

/**
 * Deep Learning Memory Engine
 * Advanced AI-powered memory system with neural networks and deep learning capabilities
 */
import { EventEmitter } from 'events';
import { MemoryMetadata } from '../types/index.js';
export interface NeuralNetworkConfig {
    architecture: 'transformer' | 'lstm' | 'gru' | 'attention' | 'hybrid';
    layers: number;
    hiddenSize: number;
    attentionHeads: number;
    dropout: number;
    learningRate: number;
    batchSize: number;
    epochs: number;
    useGPU: boolean;
    quantization: boolean;
    distillation: boolean;
}
export interface MemoryEmbedding {
    id: string;
    vector: number[];
    dimensions: number;
    model: string;
    version: string;
    timestamp: Date;
    confidence: number;
    metadata: {
        layerOutputs: number[][];
        attentionWeights: number[][];
        activationPatterns: number[];
        semanticSignature: string;
    };
}
export interface PersonalityProfile {
    userId: string;
    traits: {
        openness: number;
        conscientiousness: number;
        extraversion: number;
        agreeableness: number;
        neuroticism: number;
    };
    preferences: {
        communicationStyle: 'formal' | 'casual' | 'technical' | 'creative';
        informationDensity: 'concise' | 'detailed' | 'comprehensive';
        responseTime: 'immediate' | 'thoughtful' | 'delayed';
        learningStyle: 'visual' | 'auditory' | 'kinesthetic' | 'reading';
    };
    cognitivePatterns: {
        memoryRetention: number;
        associativeThinking: number;
        analyticalApproach: number;
        creativityIndex: number;
        focusSpan: number;
    };
    adaptationHistory: {
        interactionCount: number;
        successfulAdaptations: number;
        failedAdaptations: number;
        learningVelocity: number;
        lastUpdate: Date;
    };
}
export interface ContextualMemoryCluster {
    id: string;
    centroid: number[];
    members: string[];
    coherenceScore: number;
    temporalSpan: {
        start: Date;
        end: Date;
        duration: number;
    };
    semanticThemes: {
        primary: string;
        secondary: string[];
        confidence: number;
    };
    emotionalTone: {
        valence: number;
        arousal: number;
        dominance: number;
    };
    usagePatterns: {
        accessFrequency: number;
        retrievalSuccess: number;
        modificationRate: number;
        shareFrequency: number;
    };
}
export interface PredictiveModel {
    id: string;
    name: string;
    type: 'memory_lifecycle' | 'user_behavior' | 'content_generation' | 'interaction_flow';
    architecture: string;
    accuracy: number;
    precision: number;
    recall: number;
    f1Score: number;
    trainingData: {
        samples: number;
        features: number;
        epochs: number;
        validationSplit: number;
    };
    predictions: {
        nextMemoryType: string;
        retentionProbability: number;
        importanceScore: number;
        retrievalLikelihood: number;
        sharingProbability: number;
    };
    lastTrained: Date;
    performance: {
        latency: number;
        throughput: number;
        memoryUsage: number;
        gpuUtilization: number;
    };
}
export interface DeepInsight {
    id: string;
    type: 'pattern_discovery' | 'anomaly_detection' | 'trend_analysis' | 'relationship_mapping';
    content: string;
    confidence: number;
    evidence: {
        memoryIds: string[];
        patterns: AnalysisPattern[];
        statistics: Record<string, number>;
        visualizations: string[];
    };
    actionableRecommendations: {
        priority: 'low' | 'medium' | 'high' | 'critical';
        action: string;
        expectedImpact: string;
        implementation: string;
        timeline: string;
    }[];
    timestamp: Date;
    validity: {
        start: Date;
        end: Date;
        confidence: number;
    };
}
export interface CognitiveLoadMetrics {
    working_memory_usage: number;
    attention_fragmentation: number;
    cognitive_load_index: number;
    processing_efficiency: number;
    decision_fatigue: number;
    information_overload: number;
    mental_model_coherence: number;
    adaptive_capacity: number;
}
export interface SamplePrediction {
    nextMemoryType: string;
    retentionProbability: number;
    importanceScore: number;
    retrievalLikelihood: number;
    sharingProbability: number;
}
export interface LongTermTrend {
    description: string;
    confidence: number;
    memoryIds: string[];
    statistics: {
        trendSlope: number;
        rSquared: number;
    };
    visualizations: string[];
    recommendations: Array<{
        priority: 'low' | 'medium' | 'high';
        action: string;
        impact: string;
    }>;
}
export interface MemoryAnomaly {
    description: string;
    confidence: number;
    memoryIds: string[];
    statistics: {
        deviation: number;
        threshold: number;
    };
    visualizations: string[];
    recommendations: Array<{
        priority: 'low' | 'medium' | 'high';
        action: string;
        impact: string;
    }>;
}
export interface DeepPattern {
    description: string;
    confidence: number;
    memoryIds: string[];
    statistics: {
        correlation: number;
        frequency: number;
    };
    visualizations: string[];
    recommendations: Array<{
        priority: 'low' | 'medium' | 'high';
        action: string;
        impact: string;
    }>;
}
export interface SemanticThemes {
    primary: string;
    secondary: string[];
    confidence: number;
}
export interface MemoryCluster {
    centroid: number[];
    memberIds: number[];
    coherenceScore: number;
}
export interface TrainingResult {
    model: {
        trained: boolean;
        type: string;
    };
    avgInferenceTime: number;
    memoryUsage: number;
    trainingLoss: number;
}
export type CommunicationStyle = 'formal' | 'casual' | 'technical' | 'creative';
export type InformationDensity = 'concise' | 'detailed' | 'comprehensive';
export type ResponseTime = 'immediate' | 'thoughtful' | 'delayed';
export type LearningStyle = 'visual' | 'auditory' | 'reading';
export interface TemporalSpan {
    start: Date;
    end: Date;
    duration: number;
}
export interface ModelPerformanceHistory {
    timestamp: Date;
    accuracy: number;
    latency: number;
    throughput: number;
}
export interface NeuralNetworkInstance {
    type: string;
    layers: number;
    hiddenSize?: number;
    attentionHeads?: number;
    parameters: number[];
    performance: {
        accuracy: number;
        latency: number;
    };
}
export interface EmotionalAnalysis {
    valence: number;
    arousal: number;
    dominance: number;
}
export interface UsagePatternAnalysis {
    accessFrequency: number;
    retrievalSuccess: number;
    modificationRate: number;
    shareFrequency: number;
}
export interface PersonalityTraits {
    openness: number;
    conscientiousness: number;
    extraversion: number;
    agreeableness: number;
    neuroticism: number;
}
export interface ModelEvaluationMetrics {
    accuracy: number;
    precision: number;
    recall: number;
    f1Score: number;
}
export interface PredictionResults {
    nextMemoryType: string;
    retentionProbability: number;
    associationStrength: number;
    cognitiveLoad: number;
}
export interface AnalysisPattern {
    type: string;
    confidence: number;
    features: number[];
    metadata: Record<string, unknown>;
}
export declare class DeepLearningMemoryEngine extends EventEmitter {
    private config;
    private neuralNetworks;
    private personalityProfiles;
    private memoryClusters;
    private predictiveModels;
    private deepInsights;
    private isTraining;
    private trainingProgress;
    private modelPerformanceHistory;
    constructor(config?: Partial<NeuralNetworkConfig>);
    /**
     * Initialize neural networks for different memory tasks
     */
    private initializeNeuralNetworks;
    /**
     * Generate advanced memory embeddings using neural networks
     */
    generateAdvancedEmbedding(memory: MemoryMetadata): Promise<MemoryEmbedding>;
    /**
     * Build comprehensive personality profile from user interactions
     */
    buildPersonalityProfile(userId: string, interactions: MemoryMetadata[]): Promise<PersonalityProfile>;
    /**
     * Discover contextual memory clusters using unsupervised learning
     */
    discoverMemoryClusters(memories: MemoryMetadata[], numClusters?: number): Promise<ContextualMemoryCluster[]>;
    /**
     * Create predictive models for various memory behaviors
     */
    createPredictiveModel(type: PredictiveModel['type'], trainingData: MemoryMetadata[]): Promise<PredictiveModel>;
    /**
     * Generate deep insights from memory analysis
     */
    generateDeepInsights(memories: MemoryMetadata[]): Promise<DeepInsight[]>;
    /**
     * Calculate comprehensive cognitive load metrics
     */
    calculateCognitiveLoad(userId: string, recentMemories: MemoryMetadata[], timeWindow?: number): Promise<CognitiveLoadMetrics>;
    /**
     * Start continuous learning process
     */
    private startContinuousLearning;
    private computeTransformerLayer;
    private computeMultiHeadAttention;
    private computeFeedForward;
    private computeLSTMNetwork;
    private computeLSTMLayer;
    private extractTextFeatures;
    private extractContextFeatures;
    private extractTemporalFeatures;
    private extractSemanticFeatures;
    private analyzeCommunicationPatterns;
    private analyzeDecisionPatterns;
    private analyzeEmotionalPatterns;
    private analyzeCognitivePatterns;
    private generateRandomWeights;
    private sigmoid;
    private generateFinalEmbedding;
    private generateSemanticSignature;
    private calculateEmbeddingConfidence;
    private calculateAttentionConsistency;
    private calculateLayerAgreement;
    private calculateCorrelation;
    private extractActivationPatterns;
    private performDeepClustering;
    private calculateTemporalSpan;
    private extractSemanticThemes;
    private analyzeEmotionalTone;
    private analyzeUsagePatterns;
    private performIncrementalLearning;
    private updateModelPerformanceMetrics;
    private optimizeNetworkParameters;
    private inferCommunicationStyle;
    private inferInformationDensity;
    private inferResponseTimePreference;
    private inferLearningStyle;
    private calculateMemoryRetention;
    private calculateAssociativeThinking;
    private calculateAnalyticalApproach;
    private calculateCreativityIndex;
    private calculateFocusSpan;
    private countSuccessfulAdaptations;
    private countFailedAdaptations;
    private calculateLearningVelocity;
    private countContextSwitches;
    private calculateInterruptionFrequency;
    private prepareTrainingFeatures;
    private prepareTrainingLabels;
    private trainPredictiveModel;
    private evaluateModel;
    private generateSamplePredictions;
    private discoverDeepPatterns;
    private detectMemoryAnomalies;
    private analyzeLongTermTrends;
    /**
     * Get comprehensive analytics
     */
    getDeepLearningAnalytics(): {
        networks: unknown;
        personalityProfiles: number;
        memoryClusters: number;
        predictiveModels: number;
        insights: number;
        performance: unknown;
        trainingStatus: unknown;
    };
    private estimateSyllables;
    private isSemanticWord;
    private isEmotionalWord;
    private isTechnicalWord;
    private extractLinguisticFeatures;
    private analyzeSemanticFields;
    private analyzeDiscourseMarkers;
    private getContextualBoost;
    private extractSemanticRelations;
    private extractConcepts;
    private countAbstractWords;
    private countConcreteWords;
    private analyzeSentiment;
    private layerNormalization;
    private residualConnection;
    private generateQKV;
    private computeAttentionScores;
    private softmax;
    private applyAttentionWeights;
    private applyOutputProjection;
    private computeComponentWeights;
    private combineInputs;
    private linearTransform;
    private simulateDropout;
}
//# sourceMappingURL=DeepLearningMemoryEngine.d.ts.map