rag-lite-ts 2.1.0 → 2.2.0

package/dist/esm/core/reranking-strategies.d.ts

@@ -0,0 +1,310 @@
+/**
+ * Cross-Encoder Reranking Strategy for Text Mode
+ *
+ * Adapts the existing CrossEncoderReranker to work with the new RerankingStrategy
+ * interface defined in the Chameleon Multimodal Architecture.
+ */
+import type { RerankFunction } from './types.js';
+/**
+ * Reranking strategy interface for the Chameleon architecture
+ */
+export interface RerankingStrategy {
+    name: string;
+    supportedContentTypes: string[];
+    isEnabled: boolean;
+    rerank: RerankFunction;
+    configure(config: Record<string, any>): void;
+    getMetadata(): {
+        description: string;
+        requiredModels: string[];
+        configOptions: Record<string, any>;
+    };
+}
+/**
+ * Cross-Encoder Reranking Strategy Implementation
+ *
+ * Uses the existing CrossEncoderReranker from the text module to provide
+ * reranking functionality for text mode in the new architecture.
+ */
+export declare class CrossEncoderRerankingStrategy implements RerankingStrategy {
+    readonly name = "cross-encoder";
+    readonly supportedContentTypes: string[];
+    isEnabled: boolean;
+    private reranker;
+    private modelName?;
+    private initialized;
+    constructor(modelName?: string);
+    /**
+     * Initialize the reranker if not already done
+     */
+    private ensureInitialized;
+    /**
+     * Rerank search results using cross-encoder model
+     */
+    rerank: RerankFunction;
+    /**
+     * Configure the reranking strategy
+     */
+    configure(config: Record<string, any>): void;
+    /**
+     * Get metadata about this reranking strategy
+     */
+    getMetadata(): {
+        description: string;
+        requiredModels: string[];
+        configOptions: {
+            modelName: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+    };
+    /**
+     * Check if the strategy is ready to use
+     */
+    isReady(): Promise<boolean>;
+    /**
+     * Get the current model name being used
+     */
+    getModelName(): string;
+    /**
+     * Clean up resources
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Factory function to create a cross-encoder reranking strategy
+ *
+ * This provides a simple way to create the strategy without complex factory patterns,
+ * following the design principle of using simple functions over complex factories.
+ */
+export declare function createCrossEncoderStrategy(modelName?: string): CrossEncoderRerankingStrategy;
+/**
+ * Text-Derived Reranking Strategy Implementation
+ *
+ * Converts images to text descriptions using image-to-text models, then applies
+ * cross-encoder reranking to the text descriptions. This enables multimodal
+ * content to be reranked using text-based reranking models.
+ */
+export declare class TextDerivedRerankingStrategy implements RerankingStrategy {
+    readonly name = "text-derived";
+    readonly supportedContentTypes: string[];
+    isEnabled: boolean;
+    private crossEncoderReranker;
+    constructor(imageToTextModelName?: string, crossEncoderModelName?: string);
+    /**
+     * Generate text description for an image
+     * Uses the shared image-to-text functionality from file-processor
+     */
+    private generateImageDescription;
+    /**
+     * Rerank search results using text-derived approach
+     */
+    rerank: RerankFunction;
+    /**
+     * Configure the reranking strategy
+     */
+    configure(config: Record<string, any>): void;
+    /**
+     * Get metadata about this reranking strategy
+     */
+    getMetadata(): {
+        description: string;
+        requiredModels: string[];
+        configOptions: {
+            crossEncoderModel: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+    };
+    /**
+     * Check if the strategy is ready to use
+     */
+    isReady(): Promise<boolean>;
+    /**
+     * Get the current model names being used
+     */
+    getModelNames(): {
+        imageToText: string;
+        crossEncoder: string;
+    };
+    /**
+     * Clean up resources
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Factory function to create a text-derived reranking strategy
+ */
+export declare function createTextDerivedStrategy(imageToTextModelName?: string, crossEncoderModelName?: string): TextDerivedRerankingStrategy;
+/**
+ * Create a RerankFunction using the text-derived strategy
+ */
+export declare function createTextDerivedRerankFunction(imageToTextModelName?: string, crossEncoderModelName?: string): RerankFunction;
+/**
+ * Configuration interface for metadata reranking strategy
+ */
+interface MetadataRerankingConfig {
+    weights: {
+        filename: number;
+        contentType: number;
+        metadata: number;
+    };
+    boostFactors: {
+        diagram: number;
+        chart: number;
+        graph: number;
+        image: number;
+        screenshot: number;
+        figure: number;
+    };
+    keywordBoosts: Record<string, number>;
+}
+/**
+ * Metadata-Based Reranking Strategy Implementation
+ *
+ * Reranks search results based on filename patterns, metadata, and content type
+ * information. This strategy is particularly useful for multimodal content where
+ * semantic similarity might not capture all relevant aspects.
+ */
+export declare class MetadataRerankingStrategy implements RerankingStrategy {
+    readonly name = "metadata";
+    readonly supportedContentTypes: string[];
+    isEnabled: boolean;
+    private config;
+    constructor(config?: Partial<MetadataRerankingConfig>);
+    /**
+     * Calculate filename-based score
+     */
+    private calculateFilenameScore;
+    /**
+     * Calculate content type-based score
+     */
+    private calculateContentTypeScore;
+    /**
+     * Calculate metadata-based score
+     */
+    private calculateMetadataScore;
+    /**
+     * Rerank search results using metadata-based scoring
+     */
+    rerank: RerankFunction;
+    /**
+     * Configure the reranking strategy
+     */
+    configure(config: Record<string, any>): void;
+    /**
+     * Get metadata about this reranking strategy
+     */
+    getMetadata(): {
+        description: string;
+        requiredModels: never[];
+        configOptions: {
+            weights: {
+                type: string;
+                description: string;
+                default: {
+                    filename: number;
+                    contentType: number;
+                    metadata: number;
+                };
+                properties: {
+                    filename: {
+                        type: string;
+                        min: number;
+                        max: number;
+                    };
+                    contentType: {
+                        type: string;
+                        min: number;
+                        max: number;
+                    };
+                    metadata: {
+                        type: string;
+                        min: number;
+                        max: number;
+                    };
+                };
+            };
+            boostFactors: {
+                type: string;
+                description: string;
+                default: {
+                    diagram: number;
+                    chart: number;
+                    graph: number;
+                    image: number;
+                    screenshot: number;
+                    figure: number;
+                };
+            };
+            keywordBoosts: {
+                type: string;
+                description: string;
+                default: Record<string, number>;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+    };
+    /**
+     * Check if the strategy is ready to use
+     */
+    isReady(): Promise<boolean>;
+    /**
+     * Get current configuration
+     */
+    getConfig(): {
+        weights: {
+            filename: number;
+            contentType: number;
+            metadata: number;
+        };
+        boostFactors: {
+            diagram: number;
+            chart: number;
+            graph: number;
+            image: number;
+            screenshot: number;
+            figure: number;
+        };
+        keywordBoosts: Record<string, number>;
+    };
+    /**
+     * Clean up resources (no-op for metadata strategy)
+     */
+    cleanup(): Promise<void>;
+}
+/**
+ * Factory function to create a metadata reranking strategy
+ */
+export declare function createMetadataStrategy(config?: Partial<MetadataRerankingConfig>): MetadataRerankingStrategy;
+/**
+ * Create a RerankFunction using the metadata strategy
+ */
+export declare function createMetadataRerankFunction(config?: Partial<MetadataRerankingConfig>): RerankFunction;
+/**
+ * Create a RerankFunction using the cross-encoder strategy
+ *
+ * This provides backward compatibility with the existing RerankFunction interface
+ * while using the new strategy-based architecture internally.
+ */
+export declare function createCrossEncoderRerankFunction(modelName?: string): RerankFunction;
+export {};
+//# sourceMappingURL=reranking-strategies.d.ts.map