rag-lite-ts 2.1.0 → 2.2.0

package/dist/esm/core/error-handler.js

@@ -0,0 +1,239 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ */
+import { EXIT_CODES } from './config.js';
+/**
+ * Error categories for different types of failures
+ */
+export var ErrorCategory;
+(function (ErrorCategory) {
+    ErrorCategory["CONFIGURATION"] = "Configuration";
+    ErrorCategory["DATABASE"] = "Database";
+    ErrorCategory["MODEL"] = "Model";
+    ErrorCategory["INDEX"] = "Index";
+    ErrorCategory["FILE_SYSTEM"] = "File System";
+    ErrorCategory["EMBEDDING"] = "Embedding";
+    ErrorCategory["NETWORK"] = "Network";
+    ErrorCategory["VALIDATION"] = "Validation";
+    ErrorCategory["GENERAL"] = "General";
+})(ErrorCategory || (ErrorCategory = {}));
+/**
+ * Error severity levels
+ */
+export var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["FATAL"] = "FATAL";
+    ErrorSeverity["ERROR"] = "ERROR";
+    ErrorSeverity["WARNING"] = "WARNING";
+    ErrorSeverity["INFO"] = "INFO"; // Informational message
+})(ErrorSeverity || (ErrorSeverity = {}));
+/**
+ * Enhanced error class with category and severity
+ */
+export class CategorizedError extends Error {
+    category;
+    severity;
+    exitCode;
+    originalError;
+    constructor(message, category, severity = ErrorSeverity.ERROR, exitCode = EXIT_CODES.GENERAL_ERROR, originalError) {
+        super(message);
+        this.category = category;
+        this.severity = severity;
+        this.exitCode = exitCode;
+        this.originalError = originalError;
+        this.name = 'CategorizedError';
+    }
+}
+/**
+ * Default error context implementation - provides generic guidance
+ */
+class DefaultErrorContext {
+    getErrorMessage(error, context) {
+        return error.message;
+    }
+    getSuggestions(error, context) {
+        return [
+            'Check the error message above for specific details',
+            'Try running the command again',
+            'If the problem persists, please report it as a bug'
+        ];
+    }
+}
+// Global error context - can be injected by implementations
+let globalErrorContext = new DefaultErrorContext();
+/**
+ * Set the global error context for dependency injection
+ * @param errorContext - Implementation-specific error context
+ */
+export function setErrorContext(errorContext) {
+    globalErrorContext = errorContext;
+}
+/**
+ * Get the current error context
+ * @returns Current error context
+ */
+export function getErrorContext() {
+    return globalErrorContext;
+}
+/**
+ * Handle errors with appropriate logging and exit behavior
+ * Supports dependency injection of implementation-specific error contexts
+ * @param error - Error to handle
+ * @param context - Context where error occurred
+ * @param options - Handling options
+ */
+export function handleError(error, context, options = {}) {
+    const { category = ErrorCategory.GENERAL, severity = ErrorSeverity.ERROR, exitCode = EXIT_CODES.GENERAL_ERROR, skipError = false, showStack = false, errorContext = globalErrorContext } = options;
+    const errorObj = error instanceof Error ? error : new Error(String(error));
+    const errorMessage = errorContext.getErrorMessage(errorObj, context);
+    const timestamp = new Date().toISOString();
+    // Format error message based on severity
+    const severityPrefix = severity === ErrorSeverity.FATAL ? '🚨' :
+        severity === ErrorSeverity.ERROR ? '❌' :
+            severity === ErrorSeverity.WARNING ? '⚠️' : 'ℹ️';
+    const logMessage = `${severityPrefix} [${timestamp}] ${severity} in ${context} (${category}): ${errorMessage}`;
+    if (severity === ErrorSeverity.FATAL || severity === ErrorSeverity.ERROR) {
+        console.error(logMessage);
+    }
+    else {
+        console.log(logMessage);
+    }
+    // Show stack trace for debugging if requested
+    if (showStack && errorObj.stack) {
+        console.error('Stack trace:', errorObj.stack);
+    }
+    // Handle based on severity
+    if (severity === ErrorSeverity.FATAL) {
+        console.error('\nThe system cannot continue and will exit immediately.');
+        provideContextualGuidance(category, exitCode, errorObj, context, errorContext);
+        process.exit(exitCode);
+    }
+    else if (severity === ErrorSeverity.ERROR && !skipError) {
+        console.error('Operation failed. See error details above.');
+    }
+}
+/**
+ * Provide contextual guidance based on error category and exit code
+ * Uses dependency injection to get implementation-specific suggestions
+ */
+function provideContextualGuidance(category, exitCode, error, context, errorContext) {
+    console.error('\nTroubleshooting guidance:');
+    // Get implementation-specific suggestions first
+    const customSuggestions = errorContext.getSuggestions(error, context);
+    if (customSuggestions.length > 0) {
+        customSuggestions.forEach(suggestion => {
+            console.error(`- ${suggestion}`);
+        });
+        return;
+    }
+    // Fallback to generic category-based guidance
+    switch (category) {
+        case ErrorCategory.CONFIGURATION:
+            console.error('- Check your configuration file for syntax errors');
+            console.error('- Ensure all required fields are present and valid');
+            console.error('- Verify numeric values are positive numbers');
+            break;
+        case ErrorCategory.DATABASE:
+            console.error('- Try running "raglite rebuild" to fix database issues');
+            console.error('- Check that the database file is not locked by another process');
+            console.error('- Ensure you have write permissions in the current directory');
+            console.error('- Verify sufficient disk space is available');
+            break;
+        case ErrorCategory.MODEL:
+            console.error('- Ensure you have internet connection for model download');
+            console.error('- Check available disk space in the models directory');
+            console.error('- Try clearing the model cache and downloading again');
+            console.error('- Verify your system has sufficient memory (2GB+ recommended)');
+            break;
+        case ErrorCategory.INDEX:
+            console.error('- Try running "raglite rebuild" to recreate the vector index');
+            console.error('- Check available disk space for index files');
+            console.error('- Ensure the index file is not corrupted or locked');
+            break;
+        case ErrorCategory.FILE_SYSTEM:
+            console.error('- Check that files and directories exist and are accessible');
+            console.error('- Verify you have read/write permissions');
+            console.error('- Ensure paths are spelled correctly');
+            break;
+        case ErrorCategory.EMBEDDING:
+            console.error('- Check that the embedding model is properly loaded');
+            console.error('- Verify input text is not empty or malformed');
+            console.error('- Ensure sufficient memory for batch processing');
+            break;
+        case ErrorCategory.NETWORK:
+            console.error('- Check your internet connection');
+            console.error('- Verify firewall settings allow model downloads');
+            console.error('- Try again later if servers are temporarily unavailable');
+            break;
+        default:
+            console.error('- Check the error message above for specific details');
+            console.error('- Try running the command again');
+            console.error('- If the problem persists, please report it as a bug');
+    }
+}
+/**
+ * Wrapper for try-catch blocks with consistent error handling
+ * @param operation - Function to execute
+ * @param context - Context description
+ * @param options - Error handling options
+ */
+export async function safeExecute(operation, context, options = {}) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        handleError(error, context, options);
+        if (options.fallbackValue !== undefined) {
+            return options.fallbackValue;
+        }
+        if (options.skipError) {
+            return undefined;
+        }
+        // Re-throw if not skipping and no fallback
+        if (options.severity !== ErrorSeverity.FATAL) {
+            throw error;
+        }
+        return undefined; // This won't be reached due to process.exit in FATAL
+    }
+}
+/**
+ * Validate that a condition is true, throw categorized error if not
+ * @param condition - Condition to check
+ * @param message - Error message if condition fails
+ * @param category - Error category
+ * @param exitCode - Exit code for fatal errors
+ */
+export function assert(condition, message, category = ErrorCategory.VALIDATION, exitCode = EXIT_CODES.GENERAL_ERROR) {
+    if (!condition) {
+        throw new CategorizedError(message, category, ErrorSeverity.FATAL, exitCode);
+    }
+}
+/**
+ * Log progress with error context
+ * @param message - Progress message
+ * @param current - Current progress value
+ * @param total - Total progress value
+ */
+export function logProgress(message, current, total) {
+    const timestamp = new Date().toISOString();
+    let progressMsg = `ℹ️ [${timestamp}] ${message}`;
+    if (current !== undefined && total !== undefined) {
+        const percentage = Math.round((current / total) * 100);
+        progressMsg += ` (${current}/${total} - ${percentage}%)`;
+    }
+    console.log(progressMsg);
+}
+/**
+ * Create a categorized error for common scenarios
+ */
+export const createError = {
+    configuration: (message, exitCode = EXIT_CODES.CONFIGURATION_ERROR) => new CategorizedError(message, ErrorCategory.CONFIGURATION, ErrorSeverity.FATAL, exitCode),
+    database: (message, exitCode = EXIT_CODES.DATABASE_ERROR) => new CategorizedError(message, ErrorCategory.DATABASE, ErrorSeverity.FATAL, exitCode),
+    model: (message, exitCode = EXIT_CODES.MODEL_ERROR) => new CategorizedError(message, ErrorCategory.MODEL, ErrorSeverity.FATAL, exitCode),
+    index: (message, exitCode = EXIT_CODES.INDEX_ERROR) => new CategorizedError(message, ErrorCategory.INDEX, ErrorSeverity.FATAL, exitCode),
+    fileSystem: (message, exitCode = EXIT_CODES.FILE_NOT_FOUND) => new CategorizedError(message, ErrorCategory.FILE_SYSTEM, ErrorSeverity.FATAL, exitCode),
+    embedding: (message, severity = ErrorSeverity.ERROR) => new CategorizedError(message, ErrorCategory.EMBEDDING, severity),
+    validation: (message, exitCode = EXIT_CODES.INVALID_ARGUMENTS) => new CategorizedError(message, ErrorCategory.VALIDATION, ErrorSeverity.FATAL, exitCode)
+};
+//# sourceMappingURL=error-handler.js.map

package/dist/esm/core/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ *
+ * This module provides the clean re-export surface for the core layer, enabling
+ * dependency injection patterns for different implementations (text-only, multimodal, etc.).
+ *
+ * DEPENDENCY INJECTION ARCHITECTURE:
+ *
+ * The core layer uses explicit dependency injection to maintain clean separation between
+ * model-agnostic logic and implementation-specific components:
+ *
+ * 1. Core Classes (SearchEngine, IngestionPipeline):
+ *    - Accept injected functions (EmbedFunction, RerankFunction) in constructors
+ *    - Coordinate model-agnostic operations (database, vector index, search pipeline)
+ *    - No knowledge of specific embedding models or transformers
+ *
+ * 2. Dependency Injection Interfaces:
+ *    - EmbedFunction: (query: string, contentType?: string) => Promise<EmbeddingResult>
+ *    - RerankFunction: (query: string, results: SearchResult[], contentType?: string) => Promise<SearchResult[]>
+ *    - Support different content types (text, image, etc.) and embedding dimensions
+ *
+ * 3. Usage Patterns:
+ *
+ *    // Direct dependency injection (advanced users)
+ *    const embedFn = createTextEmbedFunction();
+ *    const rerankFn = createTextRerankFunction();
+ *    const indexManager = new IndexManager('./index.bin');
+ *    const db = await openDatabase('./db.sqlite');
+ *    const search = new SearchEngine(embedFn, indexManager, db, rerankFn);
+ *
+ *    // Factory pattern (recommended for common use cases)
+ *    const search = await TextSearchFactory.create('./index.bin', './db.sqlite');
+ *
+ * 4. Extension Points:
+ *    - New implementations (multimodal, custom models) implement the same interfaces
+ *    - Core classes remain unchanged when adding new modalities
+ *    - Plugin architecture enabled through interface-based design
+ *
+ * 5. Benefits:
+ *    - Clean separation of concerns
+ *    - Testability through mock injection
+ *    - Future extensibility without core changes
+ *    - Support for different embedding dimensions and content types
+ */
+export { type ContentDocument, type ContentChunk, type Document, type Chunk, type EmbeddingResult, type SearchResult, type SearchOptions, } from './types.js';
+export { type EmbedFunction, type RerankFunction, type EmbeddingQueryInterface, type RerankingInterface, type SearchEngineConfig, type ContentTypeStrategy, type ModelAgnosticInterface, type ExtendedEmbeddingInterface, type ExtendedRerankingInterface, type SearchPipelineInterface, type SearchDependencyFactory, InterfaceValidator } from './interfaces.js';
+export * from './adapters.js';
+export * from './config.js';
+export { type DatabaseConnection, type ContentMetadata, openDatabase, initializeSchema, insertDocument, insertChunk, upsertDocument, getChunksByEmbeddingIds, insertContentMetadata, getContentMetadata, getContentMetadataByHash, getContentMetadataByStorageType, deleteContentMetadata, getStorageStats, updateStorageStats } from './db.js';
+export { type VectorIndexOptions, VectorIndex } from './vector-index.js';
+export { type ChunkConfig, type GenericDocument, type GenericChunk, type ChunkingStrategy, ChunkingStrategyRegistry, DEFAULT_CHUNK_CONFIG, chunkingRegistry, chunkGenericDocument, registerTextChunkingStrategy } from './chunker.js';
+export * from './search.js';
+export * from './ingestion.js';
+export * from './path-manager.js';
+export { ContentManager, type MemoryContentMetadata, type ContentIngestionResult, type ContentManagerConfig } from './content-manager.js';
+export { ContentResolver, type ContentRequest, type ContentResult } from './content-resolver.js';
+export * from './error-handler.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/core/index.js

@@ -0,0 +1,69 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ *
+ * This module provides the clean re-export surface for the core layer, enabling
+ * dependency injection patterns for different implementations (text-only, multimodal, etc.).
+ *
+ * DEPENDENCY INJECTION ARCHITECTURE:
+ *
+ * The core layer uses explicit dependency injection to maintain clean separation between
+ * model-agnostic logic and implementation-specific components:
+ *
+ * 1. Core Classes (SearchEngine, IngestionPipeline):
+ *    - Accept injected functions (EmbedFunction, RerankFunction) in constructors
+ *    - Coordinate model-agnostic operations (database, vector index, search pipeline)
+ *    - No knowledge of specific embedding models or transformers
+ *
+ * 2. Dependency Injection Interfaces:
+ *    - EmbedFunction: (query: string, contentType?: string) => Promise<EmbeddingResult>
+ *    - RerankFunction: (query: string, results: SearchResult[], contentType?: string) => Promise<SearchResult[]>
+ *    - Support different content types (text, image, etc.) and embedding dimensions
+ *
+ * 3. Usage Patterns:
+ *
+ *    // Direct dependency injection (advanced users)
+ *    const embedFn = createTextEmbedFunction();
+ *    const rerankFn = createTextRerankFunction();
+ *    const indexManager = new IndexManager('./index.bin');
+ *    const db = await openDatabase('./db.sqlite');
+ *    const search = new SearchEngine(embedFn, indexManager, db, rerankFn);
+ *
+ *    // Factory pattern (recommended for common use cases)
+ *    const search = await TextSearchFactory.create('./index.bin', './db.sqlite');
+ *
+ * 4. Extension Points:
+ *    - New implementations (multimodal, custom models) implement the same interfaces
+ *    - Core classes remain unchanged when adding new modalities
+ *    - Plugin architecture enabled through interface-based design
+ *
+ * 5. Benefits:
+ *    - Clean separation of concerns
+ *    - Testability through mock injection
+ *    - Future extensibility without core changes
+ *    - Support for different embedding dimensions and content types
+ */
+// Dependency injection interfaces and utilities
+export { InterfaceValidator } from './interfaces.js';
+// Adapter utilities for converting implementations to dependency injection
+export * from './adapters.js';
+// Core configuration management - model-agnostic settings
+export * from './config.js';
+// Database operations - supports different content types through metadata
+export { openDatabase, initializeSchema, insertDocument, insertChunk, upsertDocument, getChunksByEmbeddingIds, insertContentMetadata, getContentMetadata, getContentMetadataByHash, getContentMetadataByStorageType, deleteContentMetadata, getStorageStats, updateStorageStats } from './db.js';
+// Vector index operations - works with any embedding dimensions
+export { VectorIndex } from './vector-index.js';
+// Generic chunking interfaces and strategies - supports text, image metadata, etc.
+export { ChunkingStrategyRegistry, DEFAULT_CHUNK_CONFIG, chunkingRegistry, chunkGenericDocument, registerTextChunkingStrategy } from './chunker.js';
+// Core search engine - uses dependency injection for embedding and reranking
+export * from './search.js';
+// Core ingestion pipeline - uses dependency injection for embedding
+export * from './ingestion.js';
+// Path management utilities - content-type agnostic
+export * from './path-manager.js';
+// Unified content system - handles both filesystem and memory content
+export { ContentManager } from './content-manager.js';
+export { ContentResolver } from './content-resolver.js';
+// Error handling framework - supports implementation-specific error contexts
+export * from './error-handler.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/core/ingestion.d.ts

@@ -0,0 +1,202 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ */
+import { type FileProcessorOptions } from '../file-processor.js';
+import { type ChunkConfig } from './chunker.js';
+import { IndexManager } from '../index-manager.js';
+import { type DatabaseConnection } from './db.js';
+import type { EmbedFunction } from './interfaces.js';
+import { ContentManager, type MemoryContentMetadata } from './content-manager.js';
+/**
+ * Options for the ingestion pipeline
+ */
+export interface IngestionOptions {
+    /** File processing options */
+    fileOptions?: FileProcessorOptions;
+    /** Chunking configuration */
+    chunkConfig?: ChunkConfig;
+    /** Whether to force rebuild the index */
+    forceRebuild?: boolean;
+    /** Mode for the ingestion pipeline (text or multimodal) */
+    mode?: 'text' | 'multimodal';
+    /** Content type for the ingested content */
+    contentType?: string;
+}
+/**
+ * Result of the ingestion process
+ */
+export interface IngestionResult {
+    /** Total documents processed */
+    documentsProcessed: number;
+    /** Total chunks created */
+    chunksCreated: number;
+    /** Total embeddings generated */
+    embeddingsGenerated: number;
+    /** Number of documents that failed processing */
+    documentErrors: number;
+    /** Number of chunks that failed embedding */
+    embeddingErrors: number;
+    /** Processing time in milliseconds */
+    processingTimeMs: number;
+    /** Content IDs of successfully ingested documents */
+    contentIds: string[];
+}
+/**
+ * Main ingestion pipeline class
+ * Coordinates the entire process from file discovery to vector storage
+ * Uses explicit dependency injection for clean architecture
+ */
+export declare class IngestionPipeline {
+    private embedFn;
+    private indexManager;
+    private db;
+    private defaultChunkConfig?;
+    private pathManager;
+    private contentManager;
+    /**
+     * Creates a new IngestionPipeline with explicit dependency injection
+     * Enhanced with ContentManager integration for unified content system
+     *
+     * DEPENDENCY INJECTION PATTERN:
+     * This constructor requires all dependencies to be explicitly provided, enabling:
+     * - Clean separation between core ingestion logic and implementation-specific components
+     * - Support for different embedding models and content types
+     * - Testability through mock injection
+     * - Future extensibility for multimodal content processing
+     * - Unified content management for both filesystem and memory-based ingestion
+     *
+     * @param embedFn - Function to embed document chunks into vectors
+     *   - Signature: (query: string, contentType?: string) => Promise<EmbeddingResult>
+     *   - Must handle chunk text and return consistent embedding format
+     *   - Examples:
+     *     - Text: const embedFn = (text) => textEmbedder.embedSingle(text)
+     *     - Multimodal: const embedFn = (content, type) => type === 'image' ? clipEmbedder.embedImage(content) : clipEmbedder.embedText(content)
+     *     - Custom: const embedFn = (text) => customModel.embed(text)
+     *
+     * @param indexManager - Vector index manager for storing embeddings
+     *   - Handles vector storage and indexing operations
+     *   - Must support the embedding dimensions produced by embedFn
+     *   - Example: new IndexManager('./index.bin')
+     *
+     * @param db - Database connection for metadata storage
+     *   - Stores document and chunk metadata with content type support
+     *   - Supports different content types through metadata fields
+     *   - Example: await openDatabase('./db.sqlite')
+     *
+     * @param contentManager - Optional ContentManager for unified content system
+     *   - Handles content storage routing and deduplication
+     *   - If not provided, creates default instance with standard configuration
+     *   - Example: new ContentManager(db, { contentDir: '.raglite/content' })
+     *
+     * USAGE EXAMPLES:
+     * ```typescript
+     * // Text-only ingestion pipeline with unified content system
+     * const textEmbedFn = createTextEmbedFunction();
+     * const indexManager = new IndexManager('./index.bin');
+     * const db = await openDatabase('./db.sqlite');
+     * const contentManager = new ContentManager(db);
+     * const ingestion = new IngestionPipeline(textEmbedFn, indexManager, db, undefined, contentManager);
+     *
+     * // Simple usage (ContentManager created automatically)
+     * const ingestion = new IngestionPipeline(textEmbedFn, indexManager, db);
+     *
+     * // Custom embedding implementation with memory ingestion
+     * const customEmbedFn = async (text) => ({
+     *   embedding_id: generateId(),
+     *   vector: await myCustomModel.embed(text)
+     * });
+     * const ingestion = new IngestionPipeline(customEmbedFn, indexManager, db);
+     * await ingestion.ingestFromMemory(buffer, { displayName: 'file.txt' });
+     * ```
+     */
+    constructor(embedFn: EmbedFunction, indexManager: IndexManager, db: DatabaseConnection, defaultChunkConfig?: ChunkConfig | undefined, contentManager?: ContentManager);
+    /**
+     * Ingest documents from a directory
+     * @param directoryPath - Path to directory containing documents
+     * @param options - Optional ingestion configuration
+     * @returns Promise resolving to ingestion results
+     */
+    ingestDirectory(directoryPath: string, options?: IngestionOptions): Promise<IngestionResult>;
+    /**
+     * Ingest a single file
+     * @param filePath - Path to the file to ingest
+     * @param options - Optional ingestion configuration
+     * @returns Promise resolving to ingestion results
+     */
+    ingestFile(filePath: string, options?: IngestionOptions): Promise<IngestionResult>;
+    /**
+     * Ingest content from memory buffer
+     * Enables MCP integration and real-time content processing
+     * @param content - Buffer containing the content to ingest
+     * @param metadata - Memory content metadata including display name and content type
+     * @param options - Optional ingestion configuration
+     * @returns Promise resolving to content ID for the ingested content
+     */
+    ingestFromMemory(content: Buffer, metadata: MemoryContentMetadata, options?: IngestionOptions): Promise<string>;
+    /**
+     * Ingest documents from a path (file or directory)
+     * Implements the complete pipeline: file processing → chunking → embedding → storage
+     * Enhanced to handle mixed content types (text and images) in multimodal mode
+     */
+    ingestPath(path: string, options?: IngestionOptions): Promise<IngestionResult>;
+    /**
+     * Analyze content types in the document collection
+     * @private
+     */
+    private analyzeContentTypes;
+    /**
+     * Chunk all documents and organize results with content-type awareness
+     * Enhanced to handle different content types appropriately
+     */
+    private chunkDocumentsWithContentTypes;
+    /**
+     * Generate embeddings for all chunks with content-type support
+     * Enhanced to handle different content types and pass metadata to embedding function
+     */
+    private generateEmbeddingsWithContentTypes;
+    /**
+     * Store documents and chunks in database with content-type support
+     * Enhanced to handle content type metadata and multimodal content
+     * @returns Array of content IDs for successfully stored documents
+     */
+    private storeDocumentsAndChunksWithContentTypes;
+    /**
+     * Update vector index with new embeddings (supports grouped content type storage)
+     */
+    private updateVectorIndex;
+    /**
+     * Filter documents based on ingestion mode to avoid processing incompatible content types
+     */
+    private filterDocumentsByMode;
+    /**
+     * Converts MIME type to simple content type for embedding function
+     * @param mimeType - MIME type string (e.g., 'text/plain', 'image/jpeg')
+     * @returns Simple content type ('text', 'image', etc.)
+     */
+    private getContentTypeForEmbedding;
+    /**
+     * Save the vector index to disk
+     */
+    saveIndex(): Promise<void>;
+    /**
+     * Process image content from memory using the existing image processing pipeline
+     * @private
+     */
+    private processImageFromMemory;
+    /**
+     * Process PDF content from memory using the existing PDF processing pipeline
+     * @private
+     */
+    private processPDFFromMemory;
+    /**
+     * Process DOCX content from memory using the existing DOCX processing pipeline
+     * @private
+     */
+    private processDOCXFromMemory;
+    /**
+     * Clean up resources - explicit cleanup method
+     */
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=ingestion.d.ts.map