rag-lite-ts 2.0.5 → 2.1.1

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

@@ -386,6 +386,8 @@ export class CLIPEmbedder extends BaseUniversalEmbedder {
             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 {
@@ -602,9 +604,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.1",
   "description": "Local-first TypeScript retrieval engine with Chameleon Multimodal Architecture for semantic search over text and image content",
   "type": "module",
   "main": "./dist/index.js",