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

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

/**
 * MemorAI MCP v9.1.0 - Advanced Analytics Engine
 *
 * Provides comprehensive analytics and insights for memory usage patterns,
 * knowledge gap analysis, and intelligent recommendations.
 *
 * Part of Phase 2: Enterprise Features Implementation
 */
import { OpenAI } from 'openai';
import { AdvancedMemory } from './server.js';
export interface TimeRange {
    start: Date;
    end: Date;
}
export interface UsageReport {
    timeRange: TimeRange;
    totalMemories: number;
    memoriesAdded: number;
    memoriesAccessed: number;
    searchQueries: number;
    topSearchTerms: string[];
    memoryGrowthRate: number;
    averageMemoryImportance: number;
    mostActiveProjects: string[];
    relationshipStats: RelationshipStats;
}
export interface PatternAnalysis {
    memoryCreationPatterns: TimePattern[];
    contentCategories: CategoryStats[];
    searchBehavior: SearchPattern[];
    memoryLifecycle: LifecycleStats;
    collaborationPatterns: CollaborationStats;
}
export interface TimePattern {
    hour: number;
    dayOfWeek: number;
    memoryCount: number;
    averageImportance: number;
}
export interface CategoryStats {
    category: string;
    count: number;
    percentage: number;
    averageImportance: number;
    growthRate: number;
}
export interface SearchPattern {
    query: string;
    frequency: number;
    successRate: number;
    averageResultsClicked: number;
}
export interface LifecycleStats {
    averageMemoryLifespan: number;
    accessPatternAfterCreation: number[];
    memoryRetentionRate: number;
    updateFrequency: number;
}
export interface CollaborationStats {
    sharedMemories: number;
    crossProjectReferences: number;
    teamInteractionScore: number;
    knowledgeDistribution: number;
}
export interface RelationshipStats {
    totalRelationships: number;
    averageRelationshipsPerMemory: number;
    relationshipTypeDistribution: Record<string, number>;
    strongRelationships: number;
    weakRelationships: number;
    automaticRelationships: number;
    explicitRelationships: number;
}
export interface KnowledgeGapAnalysis {
    underrepresentedTopics: string[];
    isolatedMemories: string[];
    potentialConnections: SuggestedConnection[];
    contentDuplication: DuplicationReport;
    knowledgeDistribution: DistributionAnalysis;
}
export interface SuggestedConnection {
    sourceMemoryKey: string;
    targetMemoryKey: string;
    connectionType: string;
    confidence: number;
    reasoning: string;
}
export interface DuplicationReport {
    duplicateGroups: DuplicateGroup[];
    similarityThreshold: number;
    totalDuplicates: number;
    storageWasted: number;
}
export interface DuplicateGroup {
    memoryKeys: string[];
    similarityScore: number;
    contentSample: string;
}
export interface DistributionAnalysis {
    topicCoverage: TopicCoverage[];
    depthAnalysis: DepthAnalysis;
    breadthAnalysis: BreadthAnalysis;
}
export interface TopicCoverage {
    topic: string;
    coverage: number;
    memoryCount: number;
    relationshipDensity: number;
}
export interface DepthAnalysis {
    shallowTopics: string[];
    deepTopics: string[];
    averageTopicDepth: number;
}
export interface BreadthAnalysis {
    connectedClusters: number;
    isolatedClusters: number;
    averageClusterSize: number;
    crossTopicConnections: number;
}
export interface MemoryRecommendation {
    type: 'review' | 'create' | 'connect' | 'cleanup' | 'update';
    memoryKey?: string;
    priority: 'low' | 'medium' | 'high' | 'critical';
    reasoning: string;
    actionSuggestion: string;
    confidence: number;
    estimatedImpact: string;
}
export interface SuggestedMemory {
    suggestedContent: string;
    category: string;
    priority: string;
    reasoning: string;
    relatedMemories: string[];
}
export interface SuggestedRelationship {
    sourceMemoryKey: string;
    targetMemoryKey: string;
    relationshipType: string;
    confidence: number;
    reasoning: string;
}
export interface CleanupSuggestion {
    type: 'delete' | 'merge' | 'archive' | 'update';
    memoryKeys: string[];
    reasoning: string;
    riskLevel: 'low' | 'medium' | 'high';
}
export interface MemoryHealthScore {
    overallScore: number;
    categories: {
        organization: number;
        relationships: number;
        content_quality: number;
        usage_patterns: number;
        knowledge_coverage: number;
    };
    recommendations: MemoryRecommendation[];
    trends: HealthTrend[];
}
export interface HealthTrend {
    metric: string;
    direction: 'improving' | 'declining' | 'stable';
    changeRate: number;
    timeframe: string;
}
/**
 * Advanced Analytics Engine for MemorAI MCP
 *
 * Provides comprehensive analytics, pattern analysis, and intelligent
 * recommendations for memory management optimization.
 */
export declare class MemoryAnalyticsEngine {
    private openaiClient?;
    private memories;
    private analyticsCache;
    private cacheExpiry;
    constructor(openaiClient?: OpenAI, memories?: Map<string, AdvancedMemory>);
    /**
     * Generate comprehensive usage report for a time range
     */
    generateUsageReport(agentId: string, timeRange: TimeRange): Promise<UsageReport>;
    /**
     * Analyze memory usage patterns for an agent
     */
    analyzeMemoryPatterns(agentId: string): Promise<PatternAnalysis>;
    /**
     * Identify knowledge gaps and improvement opportunities
     */
    identifyKnowledgeGaps(agentId: string): Promise<KnowledgeGapAnalysis>;
    /**
     * Generate intelligent recommendations for memory improvement
     */
    generateRecommendations(agentId: string): Promise<MemoryRecommendation[]>;
    /**
     * Calculate overall memory health score
     */
    calculateMemoryHealth(agentId: string): Promise<MemoryHealthScore>;
    private calculateRelationshipStats;
    private calculateSearchStats;
    private calculateProjectStats;
    private calculateAccessCount;
    private calculateGrowthRate;
    private calculateAverageImportance;
    private analyzeCreationPatterns;
    private analyzeContentCategories;
    private analyzeSearchBehavior;
    private analyzeMemoryLifecycle;
    private analyzeCollaborationPatterns;
    private findUnderrepresentedTopics;
    private findIsolatedMemories;
    private findPotentialConnections;
    private calculateContentSimilarity;
    private analyzeDuplication;
    private analyzeKnowledgeDistribution;
    private extractTopics;
    private calculateOrganizationScore;
    private calculateRelationshipsScore;
    private calculateContentQualityScore;
    private calculateUsagePatternsScore;
    private calculateKnowledgeCoverageScore;
    private calculateHealthTrends;
    private isValidCache;
    private cacheResult;
}
//# sourceMappingURL=analytics-engine.d.ts.map