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

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

/**
 * Autonomous Memory Optimization Engine
 * Self-healing and self-optimizing memory system with AI-driven decisions
 */
import { MemoryMetadata } from '../types/index.js';
import { MemoryIntelligenceReport } from './MemoryIntelligenceCoordinator.js';
export interface OptimizationRule {
    id: string;
    name: string;
    condition: (context: OptimizationContext) => boolean;
    action: (context: OptimizationContext) => Promise<OptimizationAction>;
    priority: number;
    enabled: boolean;
    metadata: {
        description: string;
        category: OptimizationCategory;
        impact: 'low' | 'medium' | 'high';
        risk: 'low' | 'medium' | 'high';
    };
}
export interface OptimizationContext {
    memories: MemoryMetadata[];
    performance: {
        queryLatency: number;
        memoryUsage: number;
        cacheHitRate: number;
        errorRate: number;
    };
    intelligence: MemoryIntelligenceReport;
    systemLoad: {
        cpu: number;
        memory: number;
        storage: number;
    };
    timeWindow: {
        start: Date;
        end: Date;
    };
}
export interface CacheOptimizationParams {
    newCacheSize: number;
    evictionPolicy: string;
}
export interface IndexRebuildParams {
    indexType: string;
    dimensions: number;
}
export interface MemoryArchiveParams {
    ageThreshold: number;
    accessThreshold: number;
}
export interface RelationshipPruningParams {
    strengthThreshold: number;
    confidenceThreshold: number;
}
export interface EmbeddingRefreshParams {
    batchSize: number;
    model: string;
}
export type OptimizationParams = CacheOptimizationParams | IndexRebuildParams | MemoryArchiveParams | RelationshipPruningParams | EmbeddingRefreshParams | Record<string, unknown>;
export interface OptimizationAction {
    type: OptimizationActionType;
    description: string;
    parameters: OptimizationParams;
    expectedImpact: {
        performance: number;
        accuracy: number;
        resources: number;
    };
    rollbackPlan?: () => Promise<boolean>;
}
export type OptimizationCategory = 'performance' | 'accuracy' | 'storage' | 'security' | 'reliability' | 'scalability';
export type OptimizationActionType = 'cache_optimization' | 'index_rebuild' | 'memory_archive' | 'relationship_pruning' | 'embedding_refresh' | 'threshold_adjustment' | 'clustering_update' | 'pattern_consolidation';
export interface AutonomousConfig {
    enabled: boolean;
    optimizationInterval: number;
    maxActionsPerCycle: number;
    riskThreshold: 'low' | 'medium' | 'high';
    requireApproval: boolean;
    rollbackEnabled: boolean;
    performanceTargets: {
        maxQueryLatency: number;
        minCacheHitRate: number;
        maxMemoryUsage: number;
        maxErrorRate: number;
    };
}
export declare class AutonomousMemoryOptimizer {
    private config;
    private intelligenceCoordinator;
    private performanceOptimizer;
    private optimizationRules;
    private optimizationHistory;
    private isRunning;
    private lastOptimization;
    constructor(config?: Partial<AutonomousConfig>);
    /**
     * Start autonomous optimization cycle
     */
    startAutonomousOptimization(): Promise<void>;
    /**
     * Stop autonomous optimization
     */
    stopAutonomousOptimization(): void;
    /**
     * Run single optimization cycle
     */
    private runOptimizationCycle;
    /**
     * Gather current system context for optimization decisions
     */
    private gatherOptimizationContext;
    /**
     * Identify optimization opportunities based on current context
     */
    private identifyOptimizations;
    /**
     * Execute selected optimizations
     */
    private executeOptimizations;
    /**
     * Execute a specific optimization action
     */
    private executeOptimizationAction;
    /**
     * Initialize built-in optimization rules
     */
    private initializeOptimizationRules;
    /**
     * Check if risk level is acceptable based on configuration
     */
    private isRiskAcceptable;
    /**
     * Sleep utility function
     */
    private sleep;
    private optimizeCache;
    private rebuildIndexes;
    private archiveOldMemories;
    private pruneWeakRelationships;
    private refreshEmbeddings;
    private adjustThresholds;
    private updateClustering;
    private consolidatePatterns;
    /**
     * Get current memory usage statistics
     */
    private getCurrentMemoryUsage;
    /**
     * Apply cache configuration to the memory system
     */
    private applyCacheConfiguration;
    /**
     * Get estimated record count for index type
     */
    private getIndexRecordCount;
    /**
     * Calculate estimated rebuild time based on index type and record count
     */
    private calculateRebuildTime;
    /**
     * Perform the actual index rebuild operation
     */
    private performIndexRebuild;
    /**
     * Verify index integrity after rebuild
     */
    private verifyIndexIntegrity;
    private getVectorIndexRecordCount;
    private getTextIndexRecordCount;
    private getSemanticIndexRecordCount;
    private getGraphIndexRecordCount;
    private getTemporalIndexRecordCount;
    private getIndexRebuildSteps;
    private calculateStepTime;
    private validateRebuildStep;
    private calculateStepValidationScore;
    private getIntegrityChecks;
    private performIntegrityCheck;
    private calculateIntegrityScore;
    /**
     * Find memories eligible for archiving based on age and access criteria
     */
    private findMemoriesForArchiving;
    private calculateArchiveCandidateRatio;
    private calculateOldMemoryConfidence;
    private calculateBaseConfidenceFromAge;
    private calculateAccessPatternModifier;
    private calculateContentQualityModifier;
    private calculateRelationshipStrengthModifier;
    private generateOldMemoryDate;
    private generateWeibullSample;
    private generateDeterministicUniform;
    private calculateLowImportanceScore;
    private calculateTemporalImportanceFactor;
    private calculateContentImportanceFactor;
    private calculateRelationshipImportanceFactor;
    private calculateAccessImportanceFactor;
    private calculateImportanceVariance;
    private generateLowAccessCount;
    private generatePoissonSample;
    private generateBetaRandom;
    private calculateCompressionRatio;
    private calculateStepFailureProbability;
    private shouldStepFail;
    private calculateMemoryComplexity;
    private hashString;
    private archiveMemoryBatch;
    /**
     * Update archive statistics after successful archiving
     */
    private updateArchiveStatistics;
    /**
     * Get optimization status and metrics
     */
    getOptimizationStatus(): {
        isRunning: boolean;
        lastOptimization: Date | null;
        totalOptimizations: number;
        successRate: number;
        averageImpact: number;
        recommendations: string[];
    };
    /**
     * Add custom optimization rule
     */
    addOptimizationRule(rule: OptimizationRule): void;
    /**
     * Get optimization history
     */
    getOptimizationHistory(limit?: number): typeof this.optimizationHistory;
    private calculateQueryLatency;
    private calculateMemoryUsage;
    private calculateCacheHitRate;
    private calculateErrorRate;
    private getCpuUsage;
    private getMemoryUsage;
    private getStorageUsage;
    private getSystemLoadFactor;
    private getMetrics;
    private calculateBaseMetricCount;
    private getTimeframeFactor;
    private getMetricInterval;
    private calculateCacheHitProbability;
    private calculateOperationStatus;
    private calculateBurstErrorFactor;
    private getSystemMetrics;
    private calculateCpuUsage;
    private calculateSystemMemoryUsage;
    private calculateStorageUsage;
    private getActiveOperations;
    private getCacheSize;
    private getStoredMemoryCount;
    private calculateArchiveSize;
    private getAvailableArchiveSpace;
}
//# sourceMappingURL=AutonomousMemoryOptimizer.d.ts.map