rag-lite-ts 2.0.2 → 2.0.4

package/dist/core/ingestion.js

@@ -59,7 +59,7 @@ export class IngestionPipeline {
      * USAGE EXAMPLES:
      * ```typescript
      * // Text-only ingestion pipeline with unified content system
-     * const textEmbedFn = await createTextEmbedder();
+     * const textEmbedFn = createTextEmbedFunction();
      * const indexManager = new IndexManager('./index.bin');
      * const db = await openDatabase('./db.sqlite');
      * const contentManager = new ContentManager(db);
@@ -428,19 +428,6 @@ export class IngestionPipeline {
         console.log(`✓ Chunking complete: Created ${totalChunks} chunks from ${documentChunks.length} documents`);
         return { documentChunks, allChunks, totalChunks };
     }
-    /**
-     * Chunk all documents and organize results (legacy method for backward compatibility)
-     * @deprecated Use chunkDocumentsWithContentTypes for multimodal support
-     */
-    async chunkDocuments(documents, chunkConfig) {
-        const result = await this.chunkDocumentsWithContentTypes(documents, chunkConfig);
-        // Convert to legacy format for backward compatibility
-        return {
-            documentChunks: result.documentChunks,
-            allChunks: result.allChunks.map(chunk => chunk.text),
-            totalChunks: result.totalChunks
-        };
-    }
     /**
      * Generate embeddings for all chunks with content-type support
      * Enhanced to handle different content types and pass metadata to embedding function
@@ -488,15 +475,6 @@ export class IngestionPipeline {
             throw new Error(`Embedding generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
-    /**
-     * Generate embeddings for all chunks with error handling (legacy method for backward compatibility)
-     * @deprecated Use generateEmbeddingsWithContentTypes for multimodal support
-     */
-    async generateEmbeddings(chunkTexts) {
-        // Convert to new format for backward compatibility
-        const chunks = chunkTexts.map(text => ({ text, contentType: 'text' }));
-        return this.generateEmbeddingsWithContentTypes(chunks);
-    }
     /**
      * Store documents and chunks in database with content-type support
      * Enhanced to handle content type metadata and multimodal content
@@ -584,13 +562,6 @@ export class IngestionPipeline {
         console.log(`✓ Storage complete: ${documentsStored} documents, ${totalChunksStored} chunks saved to database`);
         return contentIds;
     }
-    /**
-     * Store documents and chunks in database (legacy method for backward compatibility)
-     * @deprecated Use storeDocumentsAndChunksWithContentTypes for multimodal support
-     */
-    async storeDocumentsAndChunks(documentChunks, embeddings) {
-        await this.storeDocumentsAndChunksWithContentTypes(documentChunks, embeddings);
-    }
     /**
      * Update vector index with new embeddings
      */

package/dist/core/interfaces.d.ts

@@ -35,7 +35,7 @@
  * });
  *
  * // Factory with custom configuration
- * const ingestion = await TextIngestionFactory.create('./db.sqlite', './index.bin', {
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
  *   chunkSize: 300,
  *   chunkOverlap: 50
  * });

package/dist/core/interfaces.js

@@ -35,7 +35,7 @@
  * });
  *
  * // Factory with custom configuration
- * const ingestion = await TextIngestionFactory.create('./db.sqlite', './index.bin', {
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
  *   chunkSize: 300,
  *   chunkOverlap: 50
  * });

package/dist/core/model-registry.d.ts

@@ -113,8 +113,4 @@ export declare function getRecommendedBatchSize(modelName: string): number;
  * Default model names for different types
  */
 export declare const DEFAULT_MODELS: Record<ModelType, string>;
-/**
- * Model type mappings for backward compatibility
- */
-export declare const MODEL_TYPE_ALIASES: Record<string, ModelType>;
 //# sourceMappingURL=model-registry.d.ts.map

package/dist/core/model-registry.js

@@ -403,13 +403,9 @@ export const DEFAULT_MODELS = {
     'sentence-transformer': 'sentence-transformers/all-MiniLM-L6-v2',
     'clip': 'Xenova/clip-vit-base-patch32'
 };
-/**
- * Model type mappings for backward compatibility
- */
-export const MODEL_TYPE_ALIASES = {
-    'text': 'sentence-transformer',
-    'multimodal': 'clip',
-    'sentence': 'sentence-transformer',
-    'embedding': 'sentence-transformer'
-};
+// =============================================================================
+// REMOVED IN v3.0.0: MODEL_TYPE_ALIASES
+// =============================================================================
+// Model type aliases have been removed as they were not used anywhere in the codebase.
+// Use ModelType directly: 'sentence-transformer' or 'clip'
 //# sourceMappingURL=model-registry.js.map

package/dist/core/search.d.ts

@@ -54,8 +54,8 @@ export declare class SearchEngine {
      * USAGE EXAMPLES:
      * ```typescript
      * // Text-only search engine
-     * const textEmbedFn = await createTextEmbedder();
-     * const textRerankFn = await createTextReranker();
+     * const textEmbedFn = createTextEmbedFunction();
+     * const textRerankFn = createTextRerankFunction();
      * const indexManager = new IndexManager('./index.bin');
      * const db = await openDatabase('./db.sqlite');
      * const search = new SearchEngine(textEmbedFn, indexManager, db, textRerankFn);

package/dist/core/search.js

@@ -53,8 +53,8 @@ export class SearchEngine {
      * USAGE EXAMPLES:
      * ```typescript
      * // Text-only search engine
-     * const textEmbedFn = await createTextEmbedder();
-     * const textRerankFn = await createTextReranker();
+     * const textEmbedFn = createTextEmbedFunction();
+     * const textRerankFn = createTextRerankFunction();
      * const indexManager = new IndexManager('./index.bin');
      * const db = await openDatabase('./db.sqlite');
      * const search = new SearchEngine(textEmbedFn, indexManager, db, textRerankFn);

package/dist/factories/index.d.ts

@@ -1,45 +1,27 @@
 /**
- * Factory exports for creating text-specific RAG instances
+ * Factory exports for creating RAG instances
  * Provides convenient factory functions for common use cases
  *
  * This module serves as the main entry point for factory functions that
- * simplify the creation of text-based search and ingestion systems.
+ * simplify the creation of search and ingestion systems.
  * The factories handle complex initialization while providing clean APIs.
  *
  * MAIN FACTORY CLASSES:
- * - TextSearchFactory: Creates SearchEngine instances for text search
- * - TextIngestionFactory: Creates IngestionPipeline instances for text ingestion
- * - TextRAGFactory: Creates both search and ingestion instances together
- * - TextFactoryHelpers: Utility functions for validation and error recovery
- *
- * CONVENIENCE ALIASES:
- * - SearchFactory: Alias for TextSearchFactory
- * - IngestionFactory: Alias for TextIngestionFactory
- * - RAGFactory: Alias for TextRAGFactory
+ * - IngestionFactory: Creates IngestionPipeline instances for document ingestion
+ * - SearchFactory: Creates SearchEngine with automatic mode detection (recommended)
  *
  * @example
  * ```typescript
- * import { TextSearchFactory, TextIngestionFactory } from './factories';
- *
- * // Create search engine
- * const search = await TextSearchFactory.create('./index.bin', './db.sqlite');
+ * import { IngestionFactory, SearchFactory } from './factories';
  *
  * // Create ingestion pipeline
- * const ingestion = await TextIngestionFactory.create('./db.sqlite', './index.bin');
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin');
  *
- * // Or create both together
- * import { TextRAGFactory } from './factories';
- * const { searchEngine, ingestionPipeline } = await TextRAGFactory.createBoth(
- *   './index.bin',
- *   './db.sqlite'
- * );
+ * // Create search engine with automatic mode detection
+ * const search = await SearchFactory.create('./index.bin', './db.sqlite');
  * ```
  */
-export { TextSearchFactory, TextIngestionFactory, TextRAGFactory, TextFactoryHelpers } from './text-factory.js';
-export { PolymorphicSearchFactory } from './polymorphic-factory.js';
-export type { PolymorphicSearchOptions } from './polymorphic-factory.js';
-export type { TextSearchOptions, TextIngestionOptions, ContentSystemConfig } from './text-factory.js';
-export { TextSearchFactory as SearchFactory } from './text-factory.js';
-export { TextIngestionFactory as IngestionFactory } from './text-factory.js';
-export { TextRAGFactory as RAGFactory } from './text-factory.js';
+export { IngestionFactory } from './ingestion-factory.js';
+export { SearchFactory } from './search-factory.js';
+export type { IngestionFactoryOptions, ContentSystemConfig } from './ingestion-factory.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/factories/index.js

@@ -1,46 +1,29 @@
 /**
- * Factory exports for creating text-specific RAG instances
+ * Factory exports for creating RAG instances
  * Provides convenient factory functions for common use cases
  *
  * This module serves as the main entry point for factory functions that
- * simplify the creation of text-based search and ingestion systems.
+ * simplify the creation of search and ingestion systems.
  * The factories handle complex initialization while providing clean APIs.
  *
  * MAIN FACTORY CLASSES:
- * - TextSearchFactory: Creates SearchEngine instances for text search
- * - TextIngestionFactory: Creates IngestionPipeline instances for text ingestion
- * - TextRAGFactory: Creates both search and ingestion instances together
- * - TextFactoryHelpers: Utility functions for validation and error recovery
- *
- * CONVENIENCE ALIASES:
- * - SearchFactory: Alias for TextSearchFactory
- * - IngestionFactory: Alias for TextIngestionFactory
- * - RAGFactory: Alias for TextRAGFactory
+ * - IngestionFactory: Creates IngestionPipeline instances for document ingestion
+ * - SearchFactory: Creates SearchEngine with automatic mode detection (recommended)
  *
  * @example
  * ```typescript
- * import { TextSearchFactory, TextIngestionFactory } from './factories';
- *
- * // Create search engine
- * const search = await TextSearchFactory.create('./index.bin', './db.sqlite');
+ * import { IngestionFactory, SearchFactory } from './factories';
  *
  * // Create ingestion pipeline
- * const ingestion = await TextIngestionFactory.create('./db.sqlite', './index.bin');
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin');
  *
- * // Or create both together
- * import { TextRAGFactory } from './factories';
- * const { searchEngine, ingestionPipeline } = await TextRAGFactory.createBoth(
- *   './index.bin',
- *   './db.sqlite'
- * );
+ * // Create search engine with automatic mode detection
+ * const search = await SearchFactory.create('./index.bin', './db.sqlite');
  * ```
  */
 // Main factory classes
-export { TextSearchFactory, TextIngestionFactory, TextRAGFactory, TextFactoryHelpers } from './text-factory.js';
-// Polymorphic factory for mode-aware search
-export { PolymorphicSearchFactory } from './polymorphic-factory.js';
-// Convenience re-exports for common patterns
-export { TextSearchFactory as SearchFactory } from './text-factory.js';
-export { TextIngestionFactory as IngestionFactory } from './text-factory.js';
-export { TextRAGFactory as RAGFactory } from './text-factory.js';
+export { IngestionFactory } from './ingestion-factory.js';
+// Polymorphic search factory (recommended for automatic mode detection)
+// Re-exported from core for convenience
+export { SearchFactory } from './search-factory.js';
 //# sourceMappingURL=index.js.map

package/dist/factories/ingestion-factory.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Factory functions for creating text-specific search and ingestion instances
+ * Handles complex initialization logic while providing clean API for common use cases
+ *
+ * FACTORY PATTERN BENEFITS:
+ * - Abstracts complex initialization (model loading, database setup, index initialization)
+ * - Provides simple API for common use cases while preserving access to dependency injection
+ * - Clear validation and error handling without fallback mechanisms
+ * - Supports different embedding models and configurations
+ * - Enables clean separation between simple usage and advanced customization
+ *
+ * MODE SELECTION GUIDE:
+ * - Text Mode (default): Optimized for text-only content
+ *   - Uses sentence-transformer models (fast, accurate for text)
+ *   - Images converted to text descriptions
+ *   - Best for: document search, text clustering, semantic similarity
+ *
+ * - Multimodal Mode: Optimized for mixed text/image content
+ *   - Uses CLIP models (unified embedding space)
+ *   - True cross-modal search (text finds images, images find text)
+ *   - Best for: image search, visual QA, multimodal retrieval
+ *
+ * USAGE PATTERNS:
+ *
+ * 1. Mode Selection:
+ * ```typescript
+ * // Text mode (default) - optimized for text-only content
+ * const textIngestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
+ *   mode: 'text',
+ *   embeddingModel: 'sentence-transformers/all-MiniLM-L6-v2'
+ * });
+ *
+ * // Multimodal mode - enables cross-modal search
+ * const multimodalIngestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
+ *   mode: 'multimodal',
+ *   embeddingModel: 'Xenova/clip-vit-base-patch32',
+ *   rerankingStrategy: 'text-derived'
+ * });
+ * ```
+ */
+import { IngestionPipeline } from '../core/ingestion.js';
+/**
+ * Content system configuration options
+ */
+export interface ContentSystemConfig {
+    /** Content directory path (default: '.raglite/content') */
+    contentDir?: string;
+    /** Maximum file size in bytes (default: 50MB) */
+    maxFileSize?: number;
+    /** Maximum content directory size in bytes (default: 2GB) */
+    maxContentDirSize?: number;
+    /** Enable content deduplication (default: true) */
+    enableDeduplication?: boolean;
+    /** Enable storage tracking (default: true) */
+    enableStorageTracking?: boolean;
+}
+/**
+ * Options for text ingestion factory
+ */
+export interface IngestionFactoryOptions {
+    /** Embedding model name override */
+    embeddingModel?: string;
+    /** Embedding batch size override */
+    batchSize?: number;
+    /** Chunk size override */
+    chunkSize?: number;
+    /** Chunk overlap override */
+    chunkOverlap?: number;
+    /** Whether to force rebuild the index */
+    forceRebuild?: boolean;
+    /** Mode for the ingestion pipeline (text or multimodal) */
+    mode?: 'text' | 'multimodal';
+    /** Reranking strategy for multimodal mode */
+    rerankingStrategy?: 'cross-encoder' | 'text-derived' | 'metadata' | 'hybrid' | 'disabled';
+    /** Content system configuration */
+    contentSystemConfig?: ContentSystemConfig;
+}
+/**
+ * Factory for creating text-based IngestionPipeline instances
+ * Handles model loading, database initialization, and index setup
+ *
+ * This factory abstracts the complex initialization process required for text ingestion:
+ * 1. Creates necessary directories if they don't exist
+ * 2. Validates mode-model compatibility (no fallback mechanisms)
+ * 3. Loads and validates embedding models with clear error reporting
+ * 4. Establishes database connections and initializes schema
+ * 5. Stores mode configuration in database for automatic detection
+ * 6. Creates or loads vector indexes with proper configuration
+ * 7. Creates IngestionPipeline with proper dependency injection
+ *
+ * Mode Configuration:
+ * - Text Mode (default): Uses sentence-transformer models for text-only content
+ * - Multimodal Mode: Uses CLIP models for mixed text/image content
+ * - Mode is stored in database and auto-detected during search
+ * - Clear validation prevents mode-model mismatches
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin');
+ * await ingestion.ingestDirectory('./documents');
+ *
+ * // With custom configuration
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
+ *   embeddingModel: 'all-MiniLM-L6-v2',
+ *   chunkSize: 512,
+ *   chunkOverlap: 50,
+ *   forceRebuild: true
+ * });
+ *
+ * // With defaults
+ * const ingestion = await IngestionFactory.createWithDefaults({
+ *   batchSize: 32 // Faster processing
+ * });
+ * ```
+ */
+export declare class IngestionFactory {
+    /**
+     * Create an IngestionPipeline configured for text ingestion
+     *
+     * This method handles the complete initialization process:
+     * - Creates necessary directories if they don't exist
+     * - Loads text embedding model (with lazy initialization)
+     * - Opens database connection and initializes schema
+     * - Creates or loads vector index (with force rebuild option)
+     * - Creates IngestionPipeline with dependency injection
+     * - Validates the complete setup
+     *
+     * @param dbPath - Path to the SQLite database file (will be created if doesn't exist)
+     * @param indexPath - Path to the vector index file (will be created if doesn't exist)
+     * @param options - Optional configuration overrides
+     * @param options.embeddingModel - Override embedding model (default: from config)
+     * @param options.batchSize - Override embedding batch size (default: from config)
+     * @param options.chunkSize - Override chunk size (default: from config)
+     * @param options.chunkOverlap - Override chunk overlap (default: from config)
+     * @param options.forceRebuild - Force rebuild of existing index (default: false)
+     * @param options.contentSystemConfig - Content system configuration options
+     * @param options.contentSystemConfig.contentDir - Content directory path (default: '.raglite/content')
+     * @param options.contentSystemConfig.maxFileSize - Maximum file size in bytes (default: 50MB)
+     * @param options.contentSystemConfig.maxContentDirSize - Maximum content directory size (default: 2GB)
+     * @param options.contentSystemConfig.enableDeduplication - Enable content deduplication (default: true)
+     * @param options.contentSystemConfig.enableStorageTracking - Enable storage tracking (default: true)
+     * @returns Promise resolving to configured IngestionPipeline
+     * @throws {Error} If initialization fails
+     *
+     * @example
+     * ```typescript
+     * // Create ingestion pipeline with default content system
+     * const ingestion = await IngestionFactory.create('./my-db.sqlite', './my-index.bin');
+     *
+     * // Create with custom content system configuration
+     * const ingestion = await IngestionFactory.create('./my-db.sqlite', './my-index.bin', {
+     *   contentSystemConfig: {
+     *     contentDir: './custom-content',
+     *     maxFileSize: 100 * 1024 * 1024, // 100MB
+     *     maxContentDirSize: 5 * 1024 * 1024 * 1024, // 5GB
+     *     enableDeduplication: true
+     *   }
+     * });
+     *
+     * // Ingest documents from directory
+     * const result = await ingestion.ingestDirectory('./documents');
+     * console.log(`Processed ${result.documentsProcessed} documents`);
+     *
+     * // Ingest content from memory (MCP integration)
+     * const contentId = await ingestion.ingestFromMemory(buffer, {
+     *   displayName: 'uploaded-file.pdf',
+     *   contentType: 'application/pdf'
+     * });
+     *
+     * // Clean up when done
+     * await ingestion.cleanup();
+     * ```
+     */
+    static create(dbPath: string, indexPath: string, options?: IngestionFactoryOptions): Promise<IngestionPipeline>;
+    /**
+     * Create an IngestionPipeline with automatic path resolution
+     * Uses default paths based on current working directory
+     * @param options - Optional configuration overrides
+     * @returns Promise resolving to configured IngestionPipeline
+     */
+    static createWithDefaults(options?: IngestionFactoryOptions): Promise<IngestionPipeline>;
+    /**
+     * Handles mode storage during ingestion
+     * Creates or validates system info based on the provided mode and options
+     * @private
+     */
+    private static handleModeStorage;
+    /**
+     * Updates system info in the database
+     * @private
+     */
+    private static updateSystemInfo;
+    /**
+     * Validates and prepares content system configuration
+     * @private
+     */
+    private static validateAndPrepareContentSystemConfig;
+}
+//# sourceMappingURL=ingestion-factory.d.ts.map