@codai/memorai-core/dist/storage/ProductionRedisAdapter.d.ts

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

/**
 * Production Redis Storage Adapter
 * High-performance Redis adapter with clustering, connection pooling, and enterprise features
 */
import { MemoryMetadata } from '../types/index.js';
import { MemoryFilters, StorageAdapter } from './StorageAdapter.js';
export interface RedisStorageConfig {
    host: string;
    port: number;
    password?: string;
    db: number;
    enableClustering: boolean;
    clusterNodes?: Array<{
        host: string;
        port: number;
    }>;
    maxConnections: number;
    minConnections: number;
    acquireTimeout: number;
    idleTimeout: number;
    keyPrefix: string;
    commandTimeout: number;
    retryDelayOnFailover: number;
    maxRetriesPerRequest: number;
    defaultTTL: number;
    maxKeySize: number;
    maxValueSize: number;
    enableMetrics: boolean;
    healthCheckInterval: number;
    enableTLS: boolean;
    tlsOptions?: {
        ca?: string;
        cert?: string;
        key?: string;
        rejectUnauthorized?: boolean;
    };
}
export interface RedisHealthInfo {
    status: 'healthy' | 'degraded' | 'unhealthy';
    connectionCount: number;
    memoryUsage: string;
    version: string;
    uptime: number;
    connectedClients: number;
    usedMemory: number;
    totalSystemMemory: number;
    lastError?: string;
    performance: {
        averageLatency: number;
        commandsPerSecond: number;
        hitRate: number;
    };
}
export interface RedisMetrics {
    totalCommands: number;
    successfulCommands: number;
    failedCommands: number;
    averageLatency: number;
    peakLatency: number;
    cacheHits: number;
    cacheMisses: number;
    evictions: number;
    connectionPool: {
        activeConnections: number;
        idleConnections: number;
        totalConnections: number;
    };
}
/**
 * Production-grade Redis storage adapter with enterprise features
 */
export declare class ProductionRedisAdapter implements StorageAdapter {
    private redis;
    private config;
    private metrics;
    private healthStatus;
    private lastHealthCheck;
    constructor(config?: Partial<RedisStorageConfig>);
    /**
     * Initialize Redis connection with clustering support
     */
    private initializeRedisConnection;
    /**
     * Store memory data with automatic TTL and compression
     */
    store(memory: MemoryMetadata): Promise<void>;
    /**
     * Retrieve memory by ID with automatic deserialization
     */
    retrieve(id: string): Promise<MemoryMetadata | null>;
    /**
     * List memories with advanced filtering and pagination
     */
    list(filters?: MemoryFilters): Promise<MemoryMetadata[]>;
    /**
     * Update existing memory with optimistic locking
     */
    update(id: string, updates: Partial<MemoryMetadata>): Promise<void>;
    /**
     * Delete memory and clean up indexes
     */
    delete(id: string): Promise<void>;
    /**
     * Get comprehensive health information
     */
    getHealth(): Promise<RedisHealthInfo>;
    /**
     * Close Redis connections gracefully
     */
    close(): Promise<void>;
    private generateMemoryKey;
    private serializeMemory;
    private deserializeMemory;
    private validateMemorySize;
    private calculateTTL;
    private indexMemory;
    private updateAccessTime;
    private buildSearchKeys;
    private matchesFilters;
    private sortResults;
    private paginateResults;
    private updateIndexes;
    private removeFromIndexes;
    private addToIndexes;
    private updateMetrics;
    private extractInfoValue;
    private extractInfoStringValue;
    private calculateCommandsPerSecond;
    private calculateHitRate;
    private startHealthMonitoring;
    /**
     * Get current metrics for monitoring
     */
    getMetrics(): RedisMetrics;
    /**
     * Clear all stored data (use with caution)
     */
    clearAll(): Promise<void>;
    /**
     * Clear memories with optional tenant filter (implementing StorageAdapter interface)
     */
    clear(tenantId?: string): Promise<void>;
    /**
     * Bulk store operations for improved performance
     */
    bulkStore(memories: MemoryMetadata[]): Promise<void>;
}
//# sourceMappingURL=ProductionRedisAdapter.d.ts.map