rag-lite-ts 2.0.5 → 2.1.0

package/dist/mcp-server.js

@@ -31,6 +31,22 @@ import { IngestionFactory } from './factories/ingestion-factory.js';
 import { getSystemInfo } from './core/db.js';
 import { DatabaseConnectionManager } from './core/database-connection-manager.js';
 import { config, validateCoreConfig, ConfigurationError } from './core/config.js';
+/**
+ * Detect MIME type from file path or extension
+ */
+function getMimeTypeFromPath(filePath) {
+    const ext = filePath.toLowerCase().split('.').pop() || '';
+    const mimeTypes = {
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'png': 'image/png',
+        'gif': 'image/gif',
+        'webp': 'image/webp',
+        'bmp': 'image/bmp',
+        'svg': 'image/svg+xml'
+    };
+    return mimeTypes[ext] || 'image/jpeg'; // Default to JPEG if unknown
+}
 /**
  * MCP Server class that wraps RAG-lite TS functionality
  * Implements MCP protocol interface without creating REST/GraphQL endpoints
@@ -118,8 +134,8 @@ class RagLiteMCPServer {
                                 },
                                 rerank_strategy: {
                                     type: 'string',
-                                    description: 'Reranking strategy for multimodal mode. Options: text-derived (default), metadata, hybrid, disabled',
-                                    enum: ['text-derived', 'metadata', 'hybrid', 'disabled']
+                                    description: 'Reranking strategy for multimodal mode. Options: text-derived (default), disabled',
+                                    enum: ['text-derived', 'disabled']
                                 },
                                 force_rebuild: {
                                     type: 'boolean',
@@ -152,8 +168,8 @@ class RagLiteMCPServer {
                                 },
                                 rerank_strategy: {
                                     type: 'string',
-                                    description: 'Reranking strategy for multimodal mode. Options: text-derived (default), metadata, hybrid, disabled',
-                                    enum: ['text-derived', 'metadata', 'hybrid', 'disabled'],
+                                    description: 'Reranking strategy for multimodal mode. Options: text-derived (default), disabled',
+                                    enum: ['text-derived', 'disabled'],
                                     default: 'text-derived'
                                 },
                                 title: {
@@ -375,50 +391,60 @@ class RagLiteMCPServer {
             const startTime = Date.now();
             const results = await this.searchEngine.search(args.query, searchOptions);
             const searchTime = Date.now() - startTime;
-            // Format results for MCP response with content type information
-            const formattedResults = {
+            // Format results for MCP response with proper image content support
+            const textResults = {
                 query: args.query,
                 results_count: results.length,
                 search_time_ms: searchTime,
-                results: await Promise.all(results.map(async (result, index) => {
-                    const formattedResult = {
-                        rank: index + 1,
-                        score: Math.round(result.score * 100) / 100, // Round to 2 decimal places
-                        content_type: result.contentType,
-                        document: {
-                            id: result.document.id,
-                            title: result.document.title,
-                            source: result.document.source,
-                            content_type: result.document.contentType
-                        },
-                        text: result.content
-                    };
-                    // For image content, include base64-encoded image data for MCP clients
-                    if (result.contentType === 'image' && result.document.contentId) {
-                        try {
-                            const imageData = await this.searchEngine.getContent(result.document.contentId, 'base64');
-                            formattedResult.image_data = imageData;
-                            formattedResult.image_format = 'base64';
-                        }
-                        catch (error) {
-                            // If image retrieval fails, include error but don't fail the entire search
-                            formattedResult.image_error = error instanceof Error ? error.message : 'Failed to retrieve image';
-                        }
-                    }
-                    // Include metadata if available
-                    if (result.metadata) {
-                        formattedResult.metadata = result.metadata;
-                    }
-                    return formattedResult;
+                results: results.map((result, index) => ({
+                    rank: index + 1,
+                    score: Math.round(result.score * 100) / 100,
+                    content_type: result.contentType,
+                    document: {
+                        id: result.document.id,
+                        title: result.document.title,
+                        source: result.document.source,
+                        content_type: result.document.contentType
+                    },
+                    text: result.content,
+                    metadata: result.metadata,
+                    // Reference to image content if applicable
+                    has_image: result.contentType === 'image' && !!result.document.contentId
                 }))
             };
+            // Build MCP response content array
+            const responseContent = [
+                {
+                    type: 'text',
+                    text: JSON.stringify(textResults, null, 2)
+                }
+            ];
+            // Add proper MCP image content for each image result
+            for (const result of results) {
+                if (result.contentType === 'image' && result.document.contentId) {
+                    try {
+                        const imageData = await this.searchEngine.getContent(result.document.contentId, 'base64');
+                        const mimeType = getMimeTypeFromPath(result.document.source);
+                        responseContent.push({
+                            type: 'image',
+                            data: imageData,
+                            mimeType: mimeType,
+                            annotations: {
+                                audience: ['user'],
+                                priority: 0.8,
+                                title: result.document.title,
+                                source: result.document.source
+                            }
+                        });
+                    }
+                    catch (error) {
+                        // If image retrieval fails, log but don't fail the entire search
+                        console.error(`Failed to retrieve image for ${result.document.source}:`, error);
+                    }
+                }
+            }
             return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(formattedResults, null, 2),
-                    },
-                ],
+                content: responseContent
             };
         }
         catch (error) {
@@ -549,7 +575,7 @@ class RagLiteMCPServer {
                 if (mode === 'text') {
                     throw new Error('Reranking strategy parameter is only supported in multimodal mode');
                 }
-                const validStrategies = ['text-derived', 'metadata', 'hybrid', 'disabled'];
+                const validStrategies = ['text-derived', 'disabled'];
                 if (!validStrategies.includes(args.rerank_strategy)) {
                     throw new Error(`Invalid reranking strategy: ${args.rerank_strategy}. Supported strategies: ${validStrategies.join(', ')}`);
                 }
@@ -1223,48 +1249,61 @@ class RagLiteMCPServer {
             const startTime = Date.now();
             const results = await this.searchEngine.search(args.query, searchOptions);
             const searchTime = Date.now() - startTime;
-            // Format results for MCP response with content type information and image data
-            const formattedResults = {
+            // Format results for MCP response with proper image content support
+            const textResults = {
                 query: args.query,
                 content_type_filter: args.content_type || 'all',
                 results_count: results.length,
                 search_time_ms: searchTime,
-                results: await Promise.all(results.map(async (result, index) => {
-                    const formattedResult = {
-                        rank: index + 1,
-                        score: Math.round(result.score * 100) / 100,
-                        content_type: result.contentType,
-                        document: {
-                            id: result.document.id,
-                            title: result.document.title,
-                            source: result.document.source,
-                            content_type: result.document.contentType
-                        },
-                        text: result.content,
-                        metadata: result.metadata
-                    };
-                    // For image content, include base64-encoded image data for MCP clients
-                    if (result.contentType === 'image' && result.document.contentId) {
-                        try {
-                            const imageData = await this.searchEngine.getContent(result.document.contentId, 'base64');
-                            formattedResult.image_data = imageData;
-                            formattedResult.image_format = 'base64';
-                        }
-                        catch (error) {
-                            // If image retrieval fails, include error but don't fail the entire search
-                            formattedResult.image_error = error instanceof Error ? error.message : 'Failed to retrieve image';
-                        }
-                    }
-                    return formattedResult;
+                results: results.map((result, index) => ({
+                    rank: index + 1,
+                    score: Math.round(result.score * 100) / 100,
+                    content_type: result.contentType,
+                    document: {
+                        id: result.document.id,
+                        title: result.document.title,
+                        source: result.document.source,
+                        content_type: result.document.contentType
+                    },
+                    text: result.content,
+                    metadata: result.metadata,
+                    // Reference to image content if applicable
+                    has_image: result.contentType === 'image' && !!result.document.contentId
                 }))
             };
+            // Build MCP response content array
+            const responseContent = [
+                {
+                    type: 'text',
+                    text: JSON.stringify(textResults, null, 2)
+                }
+            ];
+            // Add proper MCP image content for each image result
+            for (const result of results) {
+                if (result.contentType === 'image' && result.document.contentId) {
+                    try {
+                        const imageData = await this.searchEngine.getContent(result.document.contentId, 'base64');
+                        const mimeType = getMimeTypeFromPath(result.document.source);
+                        responseContent.push({
+                            type: 'image',
+                            data: imageData,
+                            mimeType: mimeType,
+                            annotations: {
+                                audience: ['user'],
+                                priority: 0.8,
+                                title: result.document.title,
+                                source: result.document.source
+                            }
+                        });
+                    }
+                    catch (error) {
+                        // If image retrieval fails, log but don't fail the entire search
+                        console.error(`Failed to retrieve image for ${result.document.source}:`, error);
+                    }
+                }
+            }
             return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(formattedResults, null, 2),
-                    },
-                ],
+                content: responseContent
             };
         }
         catch (error) {
@@ -1418,23 +1457,6 @@ class RagLiteMCPServer {
                                 strategyInfo.accuracy = 'high';
                                 strategyInfo.use_cases = ['Mixed content with images', 'Visual documentation', 'Diagrams and charts'];
                                 break;
-                            case 'metadata':
-                                strategyInfo.description = 'Uses file metadata, filenames, and content properties for scoring without model inference';
-                                strategyInfo.requirements = ['None - uses file system metadata only'];
-                                strategyInfo.supported_content_types = ['text', 'image', 'pdf', 'docx'];
-                                strategyInfo.performance_impact = 'low';
-                                strategyInfo.accuracy = 'medium';
-                                strategyInfo.use_cases = ['Fast retrieval', 'Filename-based search', 'Content type filtering'];
-                                break;
-                            case 'hybrid':
-                                strategyInfo.description = 'Combines multiple reranking signals (semantic + metadata) with configurable weights';
-                                strategyInfo.requirements = ['Text-derived reranker', 'Metadata reranker'];
-                                strategyInfo.supported_content_types = ['text', 'image', 'pdf', 'docx'];
-                                strategyInfo.performance_impact = 'high';
-                                strategyInfo.accuracy = 'very high';
-                                strategyInfo.use_cases = ['Best overall accuracy', 'Complex multimodal collections', 'Production systems'];
-                                strategyInfo.default_weights = { semantic: 0.7, metadata: 0.3 };
-                                break;
                             case 'disabled':
                                 strategyInfo.description = 'No reranking applied - results ordered by vector similarity scores only';
                                 strategyInfo.requirements = ['None'];
@@ -1455,8 +1477,8 @@ class RagLiteMCPServer {
                 strategies_by_mode: strategiesByMode,
                 recommendations: {
                     text_mode: 'Use cross-encoder for best accuracy, disabled for best performance',
-                    multimodal_mode: 'Use hybrid for best accuracy, text-derived for good balance, metadata for fast retrieval',
-                    development: 'Start with disabled or metadata for fast iteration, upgrade to cross-encoder/text-derived for production'
+                    multimodal_mode: 'Use text-derived for best accuracy, disabled for best performance',
+                    development: 'Start with disabled for fast iteration, upgrade to cross-encoder/text-derived for production'
                 }
             };
             return {
@@ -1505,16 +1527,16 @@ class RagLiteMCPServer {
                         const db = await DatabaseConnectionManager.getConnection(config.db_file);
                         try {
                             // Get document count by content type
-                            const docsByType = await db.all(`
-                SELECT content_type, COUNT(*) as count 
-                FROM documents 
-                GROUP BY content_type
+                            const docsByType = await db.all(`
+                SELECT content_type, COUNT(*) as count 
+                FROM documents 
+                GROUP BY content_type
               `);
                             // Get chunk count by content type
-                            const chunksByType = await db.all(`
-                SELECT content_type, COUNT(*) as count 
-                FROM chunks 
-                GROUP BY content_type
+                            const chunksByType = await db.all(`
+                SELECT content_type, COUNT(*) as count 
+                FROM chunks 
+                GROUP BY content_type
               `);
                             enhancedStats.content_breakdown = {
                                 documents_by_type: docsByType.reduce((acc, row) => {

package/dist/multimodal/clip-embedder.js

@@ -338,76 +338,73 @@ export class CLIPEmbedder extends BaseUniversalEmbedder {
         if (!this.textModel || !this.tokenizer) {
             throw new Error('CLIP text model or tokenizer not initialized');
         }
-        try {
-            // Use the validated CLIPTextModelWithProjection approach (no pixel_values errors)
-            // Tokenize text with CLIP's requirements
-            // The tokenizer handles truncation at 77 TOKENS (not characters)
-            const tokens = await this.tokenizer(processedText, {
-                padding: true,
-                truncation: true,
-                max_length: 77, // CLIP's text sequence length limit (77 tokens)
-                return_tensors: 'pt'
-            });
-            // Log token information for debugging (only in development)
-            if (process.env.NODE_ENV === 'development') {
-                const tokenIds = tokens.input_ids?.data || [];
-                const actualTokenCount = Array.from(tokenIds).filter((id) => id !== 0).length;
-                if (actualTokenCount >= 77) {
-                    console.warn(`Text truncated by tokenizer: "${processedText.substring(0, 50)}..." (truncated to 77 tokens)`);
-                }
-            }
-            // Generate text embedding using CLIPTextModelWithProjection
-            const output = await this.textModel(tokens);
-            // Extract embedding from text_embeds (no pixel_values dependency)
-            const embedding = new Float32Array(output.text_embeds.data);
-            // Validate embedding dimensions and values
-            if (embedding.length !== this.dimensions) {
-                throw new Error(`CLIP embedding dimension mismatch: expected ${this.dimensions}, got ${embedding.length}`);
-            }
-            // Validate that all values are finite numbers
-            const invalidValues = Array.from(embedding).filter(val => !isFinite(val) || isNaN(val));
-            if (invalidValues.length > 0) {
-                throw new Error(`CLIP embedding contains ${invalidValues.length} invalid values`);
-            }
-            // Validate embedding quality - should not be all zeros
-            const nonZeroValues = Array.from(embedding).filter(val => Math.abs(val) > 1e-8);
-            if (nonZeroValues.length === 0) {
-                throw new Error('CLIP embedding is all zeros');
-            }
-            // Calculate embedding magnitude before normalization for quality assessment
-            const magnitudeBeforeNorm = Math.sqrt(Array.from(embedding).reduce((sum, val) => sum + val * val, 0));
-            if (magnitudeBeforeNorm < 1e-6) {
-                throw new Error(`CLIP embedding has critically low magnitude: ${magnitudeBeforeNorm.toExponential(3)}`);
-            }
-            // Apply L2-normalization (CLIP models are trained with normalized embeddings)
-            this.normalizeEmbedding(embedding);
-            // Verify normalization was successful
-            const magnitudeAfterNorm = Math.sqrt(Array.from(embedding).reduce((sum, val) => sum + val * val, 0));
-            if (Math.abs(magnitudeAfterNorm - 1.0) > 0.01) {
-                console.warn(`Warning: Embedding normalization may be imprecise (magnitude: ${magnitudeAfterNorm.toFixed(6)})`);
+        // Use the validated CLIPTextModelWithProjection approach (no pixel_values errors)
+        // Tokenize text with CLIP's requirements
+        // The tokenizer handles truncation at 77 TOKENS (not characters)
+        const tokens = await this.tokenizer(processedText, {
+            padding: true,
+            truncation: true,
+            max_length: 77, // CLIP's text sequence length limit (77 tokens)
+            return_tensors: 'pt'
+        });
+        // Log token information for debugging (only in development)
+        if (process.env.NODE_ENV === 'development') {
+            const tokenIds = tokens.input_ids?.data || [];
+            const actualTokenCount = Array.from(tokenIds).filter((id) => id !== 0).length;
+            if (actualTokenCount >= 77) {
+                console.warn(`Text truncated by tokenizer: "${processedText.substring(0, 50)}..." (truncated to 77 tokens)`);
+            }
+        }
+        // Generate text embedding using CLIPTextModelWithProjection
+        const output = await this.textModel(tokens);
+        // Extract embedding from text_embeds (no pixel_values dependency)
+        const embedding = new Float32Array(output.text_embeds.data);
+        // Validate embedding dimensions and values
+        if (embedding.length !== this.dimensions) {
+            throw new Error(`CLIP embedding dimension mismatch: expected ${this.dimensions}, got ${embedding.length}`);
+        }
+        // Validate that all values are finite numbers
+        const invalidValues = Array.from(embedding).filter(val => !isFinite(val) || isNaN(val));
+        if (invalidValues.length > 0) {
+            throw new Error(`CLIP embedding contains ${invalidValues.length} invalid values`);
+        }
+        // Validate embedding quality - should not be all zeros
+        const nonZeroValues = Array.from(embedding).filter(val => Math.abs(val) > 1e-8);
+        if (nonZeroValues.length === 0) {
+            throw new Error('CLIP embedding is all zeros');
+        }
+        // Calculate embedding magnitude before normalization for quality assessment
+        const magnitudeBeforeNorm = Math.sqrt(Array.from(embedding).reduce((sum, val) => sum + val * val, 0));
+        if (magnitudeBeforeNorm < 1e-6) {
+            throw new Error(`CLIP embedding has critically low magnitude: ${magnitudeBeforeNorm.toExponential(3)}`);
+        }
+        // Apply L2-normalization (CLIP models are trained with normalized embeddings)
+        this.normalizeEmbedding(embedding);
+        // Verify normalization was successful
+        const magnitudeAfterNorm = Math.sqrt(Array.from(embedding).reduce((sum, val) => sum + val * val, 0));
+        if (Math.abs(magnitudeAfterNorm - 1.0) > 0.01) {
+            console.warn(`Warning: Embedding normalization may be imprecise (magnitude: ${magnitudeAfterNorm.toFixed(6)})`);
+        }
+        // Log text embedding generation
+        console.log(`[CLIP] Generated text embedding for: "${processedText.substring(0, 30)}${processedText.length > 30 ? '...' : ''}"`);
+        // Generate unique embedding ID
+        const embeddingId = this.generateEmbeddingId(processedText, 'text');
+        return {
+            embedding_id: embeddingId,
+            vector: embedding,
+            contentType: 'text',
+            metadata: {
+                originalText: text,
+                processedText: processedText,
+                textLength: processedText.length,
+                embeddingMagnitudeBeforeNorm: magnitudeBeforeNorm,
+                embeddingMagnitudeAfterNorm: magnitudeAfterNorm,
+                normalized: true,
+                modelName: this.modelName,
+                modelType: this.modelType,
+                dimensions: this.dimensions
             }
-            // Generate unique embedding ID
-            const embeddingId = this.generateEmbeddingId(processedText, 'text');
-            return {
-                embedding_id: embeddingId,
-                vector: embedding,
-                contentType: 'text',
-                metadata: {
-                    originalText: text,
-                    processedText: processedText,
-                    textLength: processedText.length,
-                    embeddingMagnitudeBeforeNorm: magnitudeBeforeNorm,
-                    embeddingMagnitudeAfterNorm: magnitudeAfterNorm,
-                    normalized: true,
-                    modelName: this.modelName,
-                    modelType: this.modelType,
-                    dimensions: this.dimensions
-                }
-            };
-        }
-        catch (error) {
-            throw error;
-        }
+        };
     }
     // =============================================================================
     // IMAGE EMBEDDING METHODS
@@ -602,9 +599,11 @@ export class CLIPEmbedder extends BaseUniversalEmbedder {
             const absolutePath = path.resolve(imagePath);
             // Try to use Sharp for better Node.js support
             try {
-                const sharp = await import('sharp');
+                const sharpModule = await import('sharp');
+                const sharp = sharpModule.default;
+                sharp.concurrency(2);
                 // Use Sharp to load and get raw pixel data
-                const { data, info } = await sharp.default(absolutePath)
+                const { data, info } = await sharp(absolutePath)
                     .resize(variant.imageSize, variant.imageSize, {
                     fit: 'cover',
                     position: 'center'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rag-lite-ts",
-  "version": "2.0.5",
+  "version": "2.1.0",
   "description": "Local-first TypeScript retrieval engine with Chameleon Multimodal Architecture for semantic search over text and image content",
   "type": "module",
   "main": "./dist/index.js",