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

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

/**
 * Phase 4: Next-Generation Intelligence - Real-Time Learning Engine
 *
 * Advanced learning capabilities that continuously improve memory organization:
 * - Learns from memory usage patterns to optimize organization
 * - Adapts retrieval algorithms based on effectiveness metrics
 * - Provides real-time optimization recommendations
 * - Implements continuous improvement cycles
 */
import OpenAI from 'openai';
import { AdvancedMemory } from './server.js';
export interface MemoryUsagePattern {
    agentId: string;
    memoryId: string;
    accessFrequency: number;
    accessTiming: AccessTimePattern[];
    contextPatterns: ContextPattern[];
    successRate: number;
    collaborationPatterns: CollaborationPattern[];
}
export interface AccessTimePattern {
    timeOfDay: string;
    dayOfWeek: string;
    frequency: number;
    effectiveness: number;
}
export interface ContextPattern {
    context: string;
    frequency: number;
    co_occurringMemories: string[];
    outcomeSuccess: number;
}
export interface CollaborationPattern {
    collaboratorAgentId: string;
    sharedAccessFrequency: number;
    conflictFrequency: number;
    syntheticInsightGeneration: number;
}
export interface LearningInsights {
    agentId: string;
    insights: Insight[];
    recommendations: LearningRecommendation[];
    optimizationOpportunities: OptimizationOpportunity[];
    effectivenessScore: number;
    learningConfidence: number;
}
export interface Insight {
    type: 'usage_pattern' | 'timing_optimization' | 'context_correlation' | 'collaboration_benefit';
    description: string;
    strength: number;
    evidence: string[];
    actionable: boolean;
}
export interface LearningRecommendation {
    type: 'restructure' | 'timing' | 'context_tagging' | 'collaboration_setup';
    title: string;
    description: string;
    expectedImpact: number;
    effort: 'low' | 'medium' | 'high';
    timeline: string;
    implementation: ImplementationSteps;
}
export interface ImplementationSteps {
    steps: string[];
    automation: AutomationLevel;
    userActions: string[];
}
export interface AutomationLevel {
    canAutomate: boolean;
    automationLevel: 'full' | 'partial' | 'manual';
    automationSteps: string[];
}
export interface OptimizationOpportunity {
    area: 'retrieval_speed' | 'memory_organization' | 'context_awareness' | 'collaboration_efficiency';
    currentPerformance: number;
    potentialImprovement: number;
    difficulty: 'easy' | 'medium' | 'hard';
    resources: RequiredResource[];
}
export interface RequiredResource {
    type: 'computational' | 'time' | 'user_input' | 'data';
    amount: string;
    description: string;
}
export interface EffectivenessMetrics {
    agentId: string;
    timeRange: TimeRange;
    retrievalSuccessRate: number;
    averageRetrievalTime: number;
    memoryUtilizationRate: number;
    contextAccuracy: number;
    collaborationEffectiveness: number;
    overallSatisfaction: number;
}
export interface TimeRange {
    start: string;
    end: string;
    granularity: 'hour' | 'day' | 'week' | 'month';
}
export interface OrganizationAdaptation {
    agentId: string;
    adaptations: Adaptation[];
    expectedImprovements: ExpectedImprovement[];
    implementationPlan: ImplementationPlan;
    rollbackPlan: RollbackPlan;
}
export interface Adaptation {
    type: 'memory_clustering' | 'tag_restructuring' | 'relationship_reweighting' | 'access_optimization';
    description: string;
    impact: AdaptationImpact;
    automation: boolean;
}
export interface AdaptationImpact {
    retrievalSpeed: number;
    accuracy: number;
    userSatisfaction: number;
    systemLoad: number;
}
export interface ImplementationPlan {
    phases: ImplementationPhase[];
    timeline: string;
    risks: Risk[];
    successCriteria: SuccessCriterion[];
}
export interface ImplementationPhase {
    name: string;
    duration: string;
    activities: string[];
    dependencies: string[];
    deliverables: string[];
}
export interface Risk {
    description: string;
    probability: number;
    impact: number;
    mitigation: string;
}
export interface SuccessCriterion {
    metric: string;
    target: number;
    measurement: string;
    timeline: string;
}
export interface RollbackPlan {
    triggers: string[];
    steps: string[];
    dataBackup: boolean;
    timeline: string;
}
export interface QueryPattern {
    agentId: string;
    query: string;
    queryType: 'semantic' | 'keyword' | 'structured' | 'hybrid';
    frequency: number;
    successRate: number;
    averageResponseTime: number;
    contextFactors: string[];
    resultSatisfaction: number;
}
export interface RetrievalMetrics {
    agentId: string;
    timeRange: TimeRange;
    totalQueries: number;
    averageResponseTime: number;
    successRate: number;
    precisionRate: number;
    recallRate: number;
    userSatisfactionScore: number;
}
export interface RetrievalOptimization {
    agentId: string;
    optimizations: RetrievalOptimizationItem[];
    expectedImprovements: PerformanceImprovement[];
    implementation: OptimizationImplementation;
}
export interface RetrievalOptimizationItem {
    area: 'indexing' | 'embedding' | 'ranking' | 'caching' | 'preprocessing';
    description: string;
    technique: string;
    expectedGain: number;
}
export interface PerformanceImprovement {
    metric: 'speed' | 'accuracy' | 'relevance' | 'satisfaction';
    currentValue: number;
    projectedValue: number;
    confidence: number;
}
export interface OptimizationImplementation {
    immediate: string[];
    shortTerm: string[];
    longTerm: string[];
    experimental: string[];
}
export declare class RealTimeLearningEngine {
    private openaiClient?;
    private memories;
    private usagePatterns;
    private learningCache;
    private adaptationHistory;
    constructor(openaiClient?: OpenAI, memories?: Map<string, AdvancedMemory>);
    /**
     * Learn from memory usage patterns to improve system performance
     * Core learning capability with real-time adaptation
     */
    learnFromMemoryUsage(agentId: string, usagePatterns: MemoryUsagePattern[]): Promise<LearningInsights>;
    /**
     * Adapt memory organization based on effectiveness metrics
     * Dynamic reorganization for optimal performance
     */
    adaptMemoryOrganization(agentId: string, effectivenessMetrics: EffectivenessMetrics): Promise<OrganizationAdaptation>;
    /**
     * Optimize memory retrieval based on query patterns and performance metrics
     * Continuous improvement of search and retrieval algorithms
     */
    optimizeMemoryRetrieval(queryPatterns: QueryPattern[], performanceMetrics: RetrievalMetrics): Promise<RetrievalOptimization>;
    private extractUsageInsights;
    private analyzeFrequencyPatterns;
    private analyzeTimingPatterns;
    private analyzeContextCorrelations;
    private analyzeCollaborationPatterns;
    private generateLearningRecommendations;
    private identifyOptimizationOpportunities;
    private calculateEffectivenessScore;
    private calculateLearningConfidence;
    private calculateOrganizationScore;
    private calculateContextEffectiveness;
    private calculateAccessVariance;
    private analyzeOrganizationEffectiveness;
    private identifyImprovementAreas;
    private generateAdaptations;
    private calculateExpectedImprovements;
    private createImplementationPlan;
    private createRollbackPlan;
    private analyzeQueryPatterns;
    private analyzeRetrievalPerformance;
    private generateRetrievalOptimizations;
    private calculatePerformanceImprovements;
    private createOptimizationImplementation;
}
export interface ExpectedImprovement {
    metric: string;
    improvement: number;
}
//# sourceMappingURL=learning-engine.d.ts.map