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

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

/**
 * Phase 3: AI-Powered Memory Intelligence - Memory Evolution Engine
 *
 * Automatic memory evolution and conflict resolution:
 * - Automatically updates memories based on new information
 * - Detects and resolves memory conflicts intelligently
 * - Manages memory lifecycle and version control
 * - Provides semantic memory merging and consolidation
 */
import OpenAI from 'openai';
import { AdvancedMemory } from './server.js';
export interface EvolutionResult {
    memoryId: string;
    evolutionType: 'update' | 'merge' | 'split' | 'archive' | 'enhance';
    changes: MemoryChange[];
    confidence: number;
    reasoning: string;
    previousVersion?: MemoryVersion;
    newVersion: MemoryVersion;
}
export interface MemoryChange {
    field: string;
    previousValue: any;
    newValue: any;
    changeType: 'addition' | 'modification' | 'deletion' | 'restructure';
    confidence: number;
    source: 'ai_analysis' | 'user_input' | 'automatic_detection' | 'conflict_resolution';
}
export interface MemoryVersion {
    versionId: string;
    timestamp: string;
    content: string;
    metadata: any;
    changesSummary: string;
    createdBy: 'system' | 'user' | 'ai';
}
export interface ConflictResolution {
    conflictId: string;
    conflictType: 'content_contradiction' | 'metadata_mismatch' | 'temporal_inconsistency' | 'relationship_conflict';
    memoryIds: string[];
    resolution: Resolution;
    confidence: number;
    reasoning: string;
    appliedChanges: MemoryChange[];
}
export interface Resolution {
    strategy: 'merge' | 'prioritize' | 'split' | 'archive_old' | 'manual_review';
    primaryMemoryId: string;
    secondaryMemoryIds: string[];
    newContent?: string;
    newMetadata?: any;
    preservedElements: string[];
    discardedElements: string[];
}
export interface MemoryConflict {
    id: string;
    type: ConflictResolution['conflictType'];
    memoryIds: string[];
    severity: 'low' | 'medium' | 'high' | 'critical';
    description: string;
    detectedAt: string;
    autoResolvable: boolean;
}
export interface EvolutionRule {
    id: string;
    name: string;
    description: string;
    conditions: EvolutionCondition[];
    actions: EvolutionAction[];
    priority: number;
    enabled: boolean;
}
export interface EvolutionCondition {
    field: string;
    operator: 'equals' | 'contains' | 'greater_than' | 'less_than' | 'exists' | 'pattern_match';
    value: any;
    weight: number;
}
export interface EvolutionAction {
    type: 'update_field' | 'add_metadata' | 'merge_content' | 'create_relationship' | 'archive' | 'notify';
    parameters: Record<string, any>;
    confidence_threshold: number;
}
export interface MemoryConsolidation {
    consolidationId: string;
    sourceMemoryIds: string[];
    consolidatedMemory: AdvancedMemory;
    consolidationType: 'merge' | 'summarize' | 'restructure' | 'cross_reference';
    preservedInformation: string[];
    lostInformation: string[];
    qualityScore: number;
}
export declare class MemoryEvolutionEngine {
    private openaiClient?;
    private memories;
    private memoryVersions;
    private evolutionRules;
    private conflictHistory;
    private evolutionHistory;
    constructor(openaiClient?: OpenAI, memories?: Map<string, AdvancedMemory>);
    /**
     * Automatically update memory based on new information
     * Core evolution capability with AI-powered analysis
     */
    evolveMemory(memoryId: string, newInformation: string, context?: {
        source: string;
        confidence: number;
        timestamp?: string;
    }): Promise<EvolutionResult>;
    /**
     * Detect and resolve conflicts between memories
     * Intelligent conflict resolution with multiple strategies
     */
    resolveMemoryConflicts(conflictingMemoryIds: string[], resolutionStrategy?: 'auto' | 'conservative' | 'aggressive'): Promise<ConflictResolution>;
    /**
     * Detect potential conflicts across all memories
     * Proactive conflict detection system
     */
    detectPotentialConflicts(agentId: string): Promise<MemoryConflict[]>;
    /**
     * Consolidate related memories for better organization
     * Smart memory consolidation with preservation of important information
     */
    consolidateMemories(memoryIds: string[], consolidationType?: MemoryConsolidation['consolidationType']): Promise<MemoryConsolidation>;
    /**
     * Manage memory lifecycle automatically
     * Archive old, promote important, and clean up redundant memories
     */
    manageMemoryLifecycle(agentId: string): Promise<{
        archived: string[];
        promoted: string[];
        cleaned: string[];
        enhanced: string[];
    }>;
    private createMemoryVersion;
    private analyzeEvolutionStrategy;
    private aiAnalyzeEvolution;
    private ruleBasedEvolutionAnalysis;
    private applyEvolution;
    private updateContent;
    private mergeContent;
    private enhanceMetadata;
    private detectConflictType;
    private checkContentSimilarity;
    private checkTemporalConsistency;
    private checkMetadataConsistency;
    private determineOptimalStrategy;
    private applyConflictResolution;
    private detectContentConflicts;
    private detectMetadataConflicts;
    private detectTemporalConflicts;
    private detectRelationshipConflicts;
    private getSeverityScore;
    private analyzeConsolidationFeasibility;
    private performConsolidation;
    private summarizeMemories;
    private restructureMemories;
    private createCrossReference;
    private identifyArchiveCandidates;
    private identifyPromotionCandidates;
    private identifyDuplicates;
    private identifyEnhancementCandidates;
    private archiveMemory;
    private promoteMemory;
    private cleanupDuplicate;
    private enhanceMemory;
    private initializeDefaultRules;
}
//# sourceMappingURL=evolution-engine.d.ts.map