@samanhappy/mcphub 1.0.30 → 1.0.32

package/dist/services/vectorSearchService.js

@@ -1,5 +1,5 @@
 import { getRepositoryFactory } from '../db/index.js';
-import { getAppDataSource, isDatabaseConnected, initializeDatabase, reconnectDatabase } from '../db/connection.js';
+import { getAppDataSource, isDatabaseConnected, initializeDatabase, reconnectDatabase, } from '../db/connection.js';
 import { getServerDao } from '../dao/index.js';
 import { getSmartRoutingConfig } from '../utils/smartRouting.js';
 import { filterModelVisibleTools } from '../utils/mcpApps.js';
@@ -7,9 +7,13 @@ import { toFloat32Array } from '../utils/base64.js';
 import { truncateToTokenLimit, truncateWithHeuristic, getModelDefaultTokenLimit, } from '../utils/tokenTruncation.js';
 import { safeStringify, summarizeErrorForLogging } from '../utils/serialization.js';
 import logService from './logService.js';
-import { createHash } from 'node:crypto';
+import { scryptSync } from 'node:crypto';
 import OpenAI from 'openai';
 import axios from 'axios';
+import { logger } from '../utils/logger.js';
+// Stable salt for the toolset cache key derivation. Not secret material — it
+// only domain-separates the derivation so identical inputs remain deterministic.
+const TOOLSET_HASH_KEY = 'mcphub:toolset-embedding-cache:v1';
 const maskApiKey = (apiKey) => {
     if (!apiKey) {
         return 'missing';
@@ -223,7 +227,9 @@ const extractRetryAfterMs = (error) => {
     return undefined;
 };
 const applyConfiguredBasePacingDelay = (basePacingDelayMs) => {
-    const normalizedBaseDelay = typeof basePacingDelayMs === 'number' && !Number.isNaN(basePacingDelayMs) && basePacingDelayMs >= 0
+    const normalizedBaseDelay = typeof basePacingDelayMs === 'number' &&
+        !Number.isNaN(basePacingDelayMs) &&
+        basePacingDelayMs >= 0
         ? Math.floor(basePacingDelayMs)
         : SAFE_BASE_PACING_DELAY_MS;
     const previousBaseDelay = configuredBasePacingDelayMs;
@@ -249,7 +255,7 @@ const increaseAdaptivePacingDelay = (status) => {
     adaptivePacingDelayMs = Math.min(SAFE_MAX_PACING_DELAY_MS, adaptivePacingDelayMs + SAFE_PACING_DELAY_STEP_MS);
     lastPacingIncreaseAt = Date.now();
     if (adaptivePacingDelayMs !== previousDelay) {
-        console.warn(`[Embedding][Throttle] Increased pacing delay to ${adaptivePacingDelayMs}ms after status=${status ?? 'unknown'}`);
+        logger.warn(`[Embedding][Throttle] Increased pacing delay to ${adaptivePacingDelayMs}ms after status=${status ?? 'unknown'}`);
     }
 };
 const executeWithRetry = async (operation, context) => {
@@ -279,15 +285,15 @@ const executeWithRetry = async (operation, context) => {
                 if (retryAfterMs !== undefined && retryAfterMs > 0) {
                     // Server specified an explicit wait — honor it regardless of accumulated time.
                     waitMs = retryAfterMs;
-                    console.warn(`[Embedding][Retry] provider=${context.provider}, model=${context.model || 'unknown'}, baseURL=${context.baseURL || 'default'}, status=${status}, attempt=${attempt}, respecting Retry-After header: ${waitMs}ms`);
+                    logger.warn(`[Embedding][Retry] provider=${context.provider}, model=${context.model || 'unknown'}, baseURL=${context.baseURL || 'default'}, status=${status}, attempt=${attempt}, respecting Retry-After header: ${waitMs}ms`);
                 }
                 else {
                     // No Retry-After header: use 63 second cooldown and apply the 5-minute safety budget.
                     waitMs = 63 * 1000;
-                    console.warn(`[Embedding][Retry] provider=${context.provider}, model=${context.model || 'unknown'}, baseURL=${context.baseURL || 'default'}, status=${status}, attempt=${attempt}, applying 63s rate-limit cooldown (no Retry-After header found)`);
+                    logger.warn(`[Embedding][Retry] provider=${context.provider}, model=${context.model || 'unknown'}, baseURL=${context.baseURL || 'default'}, status=${status}, attempt=${attempt}, applying 63s rate-limit cooldown (no Retry-After header found)`);
                     if (totalRetryTimeMs + waitMs > MAX_TOTAL_RETRY_TIME_MS) {
                         const remainingMs = MAX_TOTAL_RETRY_TIME_MS - totalRetryTimeMs;
-                        console.warn(`[Embedding][Retry] Max retry time limit reached (no Retry-After). totalTime=${totalRetryTimeMs}ms, nextWait=${waitMs}ms, remaining=${remainingMs}ms, limit=${MAX_TOTAL_RETRY_TIME_MS}ms. Throwing error.`);
+                        logger.warn(`[Embedding][Retry] Max retry time limit reached (no Retry-After). totalTime=${totalRetryTimeMs}ms, nextWait=${waitMs}ms, remaining=${remainingMs}ms, limit=${MAX_TOTAL_RETRY_TIME_MS}ms. Throwing error.`);
                         throw error;
                     }
                 }
@@ -298,14 +304,14 @@ const executeWithRetry = async (operation, context) => {
                 // Fixed exponential sequence: 4s, 8s, 16s, 30s, 60s, 120s, 240s — exactly 7 attempts.
                 // No time budget imposed; all 7 attempts will be made regardless of total elapsed time.
                 if (exponentialAttempt >= RETRY_EXPONENTIAL_SEQUENCE_MS.length) {
-                    console.warn(`[Embedding][Retry] Exhausted all ${RETRY_EXPONENTIAL_SEQUENCE_MS.length} exponential backoff attempts. provider=${context.provider}, model=${context.model || 'unknown'}, status=${status}. Throwing error.`);
+                    logger.warn(`[Embedding][Retry] Exhausted all ${RETRY_EXPONENTIAL_SEQUENCE_MS.length} exponential backoff attempts. provider=${context.provider}, model=${context.model || 'unknown'}, status=${status}. Throwing error.`);
                     throw error;
                 }
                 waitMs = withJitter(RETRY_EXPONENTIAL_SEQUENCE_MS[exponentialAttempt]);
-                console.warn(`[Embedding][Retry] provider=${context.provider}, model=${context.model || 'unknown'}, baseURL=${context.baseURL || 'default'}, status=${status}, attempt=${attempt} (exponential ${exponentialAttempt + 1}/${RETRY_EXPONENTIAL_SEQUENCE_MS.length}), waiting=${waitMs}ms`);
+                logger.warn(`[Embedding][Retry] provider=${context.provider}, model=${context.model || 'unknown'}, baseURL=${context.baseURL || 'default'}, status=${status}, attempt=${attempt} (exponential ${exponentialAttempt + 1}/${RETRY_EXPONENTIAL_SEQUENCE_MS.length}), waiting=${waitMs}ms`);
                 exponentialAttempt++;
             }
-            console.log(`[Embedding][Retry] Attempt ${attempt} failed. Waiting ${waitMs}ms before retry...`);
+            logger.log(`[Embedding][Retry] Attempt ${attempt} failed. Waiting ${waitMs}ms before retry...`);
             await sleep(waitMs);
             attempt++;
         }
@@ -322,7 +328,7 @@ const withEmbeddingQueue = (operation) => {
         const pacingDelayMs = getAdaptivePacingDelayMs();
         const waitMs = lastEmbeddingCallAt === 0 ? 0 : Math.max(0, pacingDelayMs - elapsed);
         if (waitMs > 0) {
-            console.log(`[Embedding][Queue] Pacing wait ${waitMs}ms before next API call`);
+            logger.log(`[Embedding][Queue] Pacing wait ${waitMs}ms before next API call`);
             await sleep(waitMs);
         }
         lastEmbeddingCallAt = Date.now();
@@ -334,11 +340,11 @@ const withEmbeddingQueue = (operation) => {
 };
 const scheduleFullEmbeddingResync = (reason) => {
     if (fullResyncScheduled || fullResyncInProgress) {
-        console.log(`[Embedding] Full embeddings resync already in progress/scheduled. reason=${reason}`);
+        logger.log(`[Embedding] Full embeddings resync already in progress/scheduled. reason=${reason}`);
         return;
     }
     fullResyncScheduled = true;
-    console.warn(`[Embedding] Scheduling full embeddings resync. reason=${reason}`);
+    logger.warn(`[Embedding] Scheduling full embeddings resync. reason=${reason}`);
     setTimeout(async () => {
         if (fullResyncInProgress) {
             fullResyncScheduled = false;
@@ -350,7 +356,7 @@ const scheduleFullEmbeddingResync = (reason) => {
             await syncAllServerToolsEmbeddings();
         }
         catch (error) {
-            console.error('[EMBED_SYNC_ERROR] Full embeddings resync failed', { reason, error });
+            logger.error('[EMBED_SYNC_ERROR] Full embeddings resync failed', { reason, error });
         }
         finally {
             fullResyncInProgress = false;
@@ -400,7 +406,7 @@ export async function createVectorIndex(dataSource, dimensions, tableName = 'vec
         CREATE INDEX ${indexName}
         ON ${tableName} USING hnsw (${columnName} vector_cosine_ops);
       `);
-            console.log(`Created HNSW index for ${dimensions}-dimensional vectors.`);
+            logger.log(`Created HNSW index for ${dimensions}-dimensional vectors.`);
             return {
                 success: true,
                 indexType: 'hnsw',
@@ -409,14 +415,14 @@ export async function createVectorIndex(dataSource, dimensions, tableName = 'vec
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            console.warn(`HNSW index creation failed: ${errorMessage}`);
+            logger.warn(`HNSW index creation failed: ${errorMessage}`);
             // Fallback to IVFFlat if HNSW fails (e.g., older pgvector version)
             try {
                 await dataSource.query(`
           CREATE INDEX ${indexName}
           ON ${tableName} USING ivfflat (${columnName} vector_cosine_ops) WITH (lists = 100);
         `);
-                console.log(`Created IVFFlat index for ${dimensions}-dimensional vectors (fallback).`);
+                logger.log(`Created IVFFlat index for ${dimensions}-dimensional vectors (fallback).`);
                 return {
                     success: true,
                     indexType: 'ivfflat',
@@ -425,7 +431,7 @@ export async function createVectorIndex(dataSource, dimensions, tableName = 'vec
             }
             catch (ivfError) {
                 const ivfErrorMessage = ivfError instanceof Error ? ivfError.message : 'Unknown error';
-                console.warn(`IVFFlat index creation also failed: ${ivfErrorMessage}`);
+                logger.warn(`IVFFlat index creation also failed: ${ivfErrorMessage}`);
                 return {
                     success: false,
                     indexType: null,
@@ -442,7 +448,7 @@ export async function createVectorIndex(dataSource, dimensions, tableName = 'vec
         CREATE INDEX ${indexName}
         ON ${tableName} USING hnsw ((${columnName}::halfvec(${dimensions})) halfvec_cosine_ops);
       `);
-            console.log(`Created HNSW index with halfvec casting for ${dimensions}-dimensional vectors.`);
+            logger.log(`Created HNSW index with halfvec casting for ${dimensions}-dimensional vectors.`);
             return {
                 success: true,
                 indexType: 'hnsw-halfvec',
@@ -455,28 +461,28 @@ export async function createVectorIndex(dataSource, dimensions, tableName = 'vec
                 errorMessage.includes('type does not exist') ||
                 errorMessage.includes('operator class');
             if (isHalfvecNotSupported) {
-                console.warn('');
-                console.warn('═══════════════════════════════════════════════════════════════════════════');
-                console.warn('  ⚠️  HIGH-DIMENSIONAL EMBEDDING INDEX WARNING');
-                console.warn('═══════════════════════════════════════════════════════════════════════════');
-                console.warn(`  Your embeddings have ${dimensions} dimensions, which requires halfvec support.`);
-                console.warn('');
-                console.warn('  pgvector dimension limits:');
-                console.warn(`  - vector type: max ${VECTOR_MAX_DIMENSIONS} dimensions`);
-                console.warn(`  - halfvec type: max ${HALFVEC_MAX_DIMENSIONS} dimensions (pgvector 0.7.0+)`);
-                console.warn('');
-                console.warn('  RECOMMENDATIONS:');
-                console.warn('  1. Upgrade pgvector to >= 0.7.0 for halfvec support');
-                console.warn('  2. Or use a smaller embedding model:');
-                console.warn('     - text-embedding-3-small (1536 dimensions) instead of text-embedding-3-large');
-                console.warn('     - bge-m3 (1024 dimensions)');
-                console.warn('');
-                console.warn('  Vector search will work but may be slower without an optimized index.');
-                console.warn('═══════════════════════════════════════════════════════════════════════════');
-                console.warn('');
+                logger.warn('');
+                logger.warn('═══════════════════════════════════════════════════════════════════════════');
+                logger.warn('  ⚠️  HIGH-DIMENSIONAL EMBEDDING INDEX WARNING');
+                logger.warn('═══════════════════════════════════════════════════════════════════════════');
+                logger.warn(`  Your embeddings have ${dimensions} dimensions, which requires halfvec support.`);
+                logger.warn('');
+                logger.warn('  pgvector dimension limits:');
+                logger.warn(`  - vector type: max ${VECTOR_MAX_DIMENSIONS} dimensions`);
+                logger.warn(`  - halfvec type: max ${HALFVEC_MAX_DIMENSIONS} dimensions (pgvector 0.7.0+)`);
+                logger.warn('');
+                logger.warn('  RECOMMENDATIONS:');
+                logger.warn('  1. Upgrade pgvector to >= 0.7.0 for halfvec support');
+                logger.warn('  2. Or use a smaller embedding model:');
+                logger.warn('     - text-embedding-3-small (1536 dimensions) instead of text-embedding-3-large');
+                logger.warn('     - bge-m3 (1024 dimensions)');
+                logger.warn('');
+                logger.warn('  Vector search will work but may be slower without an optimized index.');
+                logger.warn('═══════════════════════════════════════════════════════════════════════════');
+                logger.warn('');
             }
             else {
-                console.warn(`HNSW halfvec index creation failed: ${errorMessage}`);
+                logger.warn(`HNSW halfvec index creation failed: ${errorMessage}`);
             }
             return {
                 success: false,
@@ -486,24 +492,24 @@ export async function createVectorIndex(dataSource, dimensions, tableName = 'vec
         }
     }
     // Strategy 3: For dimensions > 4000, no index is supported
-    console.warn('');
-    console.warn('═══════════════════════════════════════════════════════════════════════════');
-    console.warn('  ⚠️  EMBEDDING DIMENSIONS EXCEED INDEX LIMITS');
-    console.warn('═══════════════════════════════════════════════════════════════════════════');
-    console.warn(`  Your embeddings have ${dimensions} dimensions, which exceeds all limits:`);
-    console.warn(`  - vector type: max ${VECTOR_MAX_DIMENSIONS} dimensions`);
-    console.warn(`  - halfvec type: max ${HALFVEC_MAX_DIMENSIONS} dimensions`);
-    console.warn('');
-    console.warn('  RECOMMENDATIONS:');
-    console.warn('  1. Use a smaller embedding model:');
-    console.warn('     - text-embedding-3-small (1536 dimensions)');
-    console.warn('     - text-embedding-3-large (3072 dimensions) with halfvec');
-    console.warn('     - bge-m3 (1024 dimensions)');
-    console.warn('  2. Or use dimensionality reduction (PCA) to reduce vector size');
-    console.warn('');
-    console.warn('  Vector search will work but will be slow without an index.');
-    console.warn('═══════════════════════════════════════════════════════════════════════════');
-    console.warn('');
+    logger.warn('');
+    logger.warn('═══════════════════════════════════════════════════════════════════════════');
+    logger.warn('  ⚠️  EMBEDDING DIMENSIONS EXCEED INDEX LIMITS');
+    logger.warn('═══════════════════════════════════════════════════════════════════════════');
+    logger.warn(`  Your embeddings have ${dimensions} dimensions, which exceeds all limits:`);
+    logger.warn(`  - vector type: max ${VECTOR_MAX_DIMENSIONS} dimensions`);
+    logger.warn(`  - halfvec type: max ${HALFVEC_MAX_DIMENSIONS} dimensions`);
+    logger.warn('');
+    logger.warn('  RECOMMENDATIONS:');
+    logger.warn('  1. Use a smaller embedding model:');
+    logger.warn('     - text-embedding-3-small (1536 dimensions)');
+    logger.warn('     - text-embedding-3-large (3072 dimensions) with halfvec');
+    logger.warn('     - bge-m3 (1024 dimensions)');
+    logger.warn('  2. Or use dimensionality reduction (PCA) to reduce vector size');
+    logger.warn('');
+    logger.warn('  Vector search will work but will be slow without an index.');
+    logger.warn('═══════════════════════════════════════════════════════════════════════════');
+    logger.warn('');
     return {
         success: false,
         indexType: null,
@@ -568,7 +574,7 @@ async function generateEmbedding(text) {
     if (provider === 'azure_openai') {
         const azureConfig = getAzureOpenAIConfig(smartRoutingConfig);
         if (!azureConfig.endpoint || !azureConfig.apiKey) {
-            console.warn('Azure OpenAI endpoint/key not configured. Using fallback embedding method.');
+            logger.warn('Azure OpenAI endpoint/key not configured. Using fallback embedding method.');
             return generateFallbackEmbedding(text);
         }
         try {
@@ -580,7 +586,7 @@ async function generateEmbedding(text) {
         }
         catch (error) {
             const status = extractErrorStatus(error);
-            console.warn('Azure OpenAI embeddings request failed after retries', {
+            logger.warn('Azure OpenAI embeddings request failed after retries', {
                 status: status ?? 'unknown',
                 endpoint: azureConfig.endpoint || 'missing',
                 deployment: azureConfig.embeddingDeployment || 'missing',
@@ -594,7 +600,7 @@ async function generateEmbedding(text) {
     const openai = await getOpenAIClient();
     // Check if API key is configured
     if (!openai.apiKey) {
-        console.warn('OpenAI API key is not configured. Using fallback embedding method.');
+        logger.warn('OpenAI API key is not configured. Using fallback embedding method.');
         return generateFallbackEmbedding(text);
     }
     // Truncate text to the model's token limit using precise tokenization.
@@ -610,12 +616,12 @@ async function generateEmbedding(text) {
         truncatedText = await truncateToTokenLimit(text, maxTokens, config.embeddingModel, config.apiKey);
     }
     catch (truncationError) {
-        console.warn(`Token truncation failed for model ${config.embeddingModel}: ${truncationError?.message ?? String(truncationError)}. Falling back to character-based truncation.`);
+        logger.warn(`Token truncation failed for model ${config.embeddingModel}: ${truncationError?.message ?? String(truncationError)}. Falling back to character-based truncation.`);
         // As a fallback, use the shared conservative character-based heuristic (~3 chars/token)
         // to prevent oversized text from causing a failure in the embedding API call.
         truncatedText = truncateWithHeuristic(text, maxTokens);
     }
-    console.debug(`[Embedding] Truncation: ${text.length} → ${truncatedText.length} chars (${Date.now() - _truncateStart}ms, maxTokens=${maxTokens})`);
+    logger.debug(`[Embedding] Truncation: ${text.length} → ${truncatedText.length} chars (${Date.now() - _truncateStart}ms, maxTokens=${maxTokens})`);
     // Determine encoding format based on configuration
     const encodingFormatSetting = smartRoutingConfig.embeddingEncodingFormat || 'auto';
     let encodingFormat;
@@ -633,7 +639,7 @@ async function generateEmbedding(text) {
     };
     if (process.env.DEBUG === 'true') {
         const debugCurl = buildEmbeddingsDebugCurl(config.baseURL, embeddingPayload);
-        console.log(`[Embedding] HTTP request details: ${JSON.stringify({
+        logger.log(`[Embedding] HTTP request details: ${JSON.stringify({
             url: `${(config.baseURL || 'https://api.openai.com/v1').replace(/\/+$/, '')}/embeddings`,
             method: 'POST',
             headers: {
@@ -642,9 +648,9 @@ async function generateEmbedding(text) {
             },
             payload: embeddingPayload,
         }, null, 2)}`);
-        console.log(`[Embedding] Reproducible curl (copy/paste and replace <YOUR_API_KEY>):\n${debugCurl}`);
+        logger.log(`[Embedding] Reproducible curl (copy/paste and replace <YOUR_API_KEY>):\n${debugCurl}`);
     }
-    console.debug(`[Embedding] API request → model=${config.embeddingModel}, encoding_format=${encodingFormat}, input_length=${truncatedText.length} chars | input_preview: "${truncatedText.substring(0, 200).replace(/\s+/g, ' ')}"`);
+    logger.debug(`[Embedding] API request → model=${config.embeddingModel}, encoding_format=${encodingFormat}, input_length=${truncatedText.length} chars | input_preview: "${truncatedText.substring(0, 200).replace(/\s+/g, ' ')}"`);
     const _requestStart = Date.now();
     try {
         // Call OpenAI-compatible embeddings API with conservative retry/backoff policy.
@@ -657,7 +663,7 @@ async function generateEmbedding(text) {
             model: config.embeddingModel,
             baseURL: config.baseURL,
         }));
-        console.debug(`[Embedding] API response OK in ${Date.now() - _requestStart}ms`);
+        logger.debug(`[Embedding] API response OK in ${Date.now() - _requestStart}ms`);
         if (encodingFormat === 'base64' && typeof response.data[0].embedding === 'string') {
             const embeddingBase64Str = response.data[0].embedding;
             return toFloat32Array(embeddingBase64Str);
@@ -667,7 +673,7 @@ async function generateEmbedding(text) {
     }
     catch (error) {
         const status = extractErrorStatus(error);
-        console.warn('OpenAI-compatible embeddings request failed after retries', {
+        logger.warn('OpenAI-compatible embeddings request failed after retries', {
             status: status ?? 'unknown',
             baseURL: config.baseURL || 'default',
             model: config.embeddingModel || 'default',
@@ -801,7 +807,15 @@ const buildToolSetHash = (tools) => {
         inputSchema: tool.inputSchema || null,
     }))
         .sort((a, b) => a.name.localeCompare(b.name));
-    return createHash('sha256').update(stableHashSerialize(normalized)).digest('hex');
+    // Derive the cache key with a memory-hard KDF (scrypt) rather than a bare
+    // digest: inputs may embed configuration-derived content, so a deliberately
+    // expensive keyed derivation is the appropriate construction. Parameters
+    // are tuned down (~2ms) because this runs on tool-set refreshes only.
+    return scryptSync(stableHashSerialize(normalized), TOOLSET_HASH_KEY, 32, {
+        N: 2048,
+        r: 8,
+        p: 1,
+    }).toString('hex');
 };
 const buildServerSearchableText = (serverName, description) => [serverName, description || ''].filter(Boolean).join(' ');
 const parseEmbeddingMetadata = (metadata) => {
@@ -813,7 +827,7 @@ const parseEmbeddingMetadata = (metadata) => {
             return JSON.parse(metadata);
         }
         catch (error) {
-            console.error('Error parsing vector embedding metadata string', safeStringify({ error }));
+            logger.error('Error parsing vector embedding metadata string', safeStringify({ error }));
             return null;
         }
     }
@@ -865,7 +879,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
         }
         // Ensure database is initialized before starting
         if (!isDatabaseConnected()) {
-            console.log('Database not initialized, initializing...');
+            logger.log('Database not initialized, initializing...');
             await initializeDatabase();
         }
         const config = await getOpenAIConfig();
@@ -891,7 +905,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
                 const skipCheckRepo = getRepositoryFactory('vectorEmbeddings')();
                 const existingCount = await skipCheckRepo.countByServerNameAndModel(serverName, persistedEmbeddingModel);
                 if (existingCount !== tools.length) {
-                    console.log(`[Embedding] [${serverName}] Generating embeddings: existing=${existingCount}, expected=${tools.length} (model=${persistedEmbeddingModel}, hash=${expectedToolSetHash.substring(0, 12)})`);
+                    logger.log(`[Embedding] [${serverName}] Generating embeddings: existing=${existingCount}, expected=${tools.length} (model=${persistedEmbeddingModel}, hash=${expectedToolSetHash.substring(0, 12)})`);
                 }
                 else {
                     const existingIdentities = await skipCheckRepo.getToolIdentityByServerNameAndModel(serverName, persistedEmbeddingModel);
@@ -909,14 +923,14 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
                         serverEmbStatus.text_content === serverSearchableText &&
                         serverEmbStatus.hasEmbedding === true;
                     if (hasExactContentIds && hasMatchingToolSetHash && hasCurrentServerEmbedding) {
-                        console.log(`[Embedding] [${serverName}] Skipping — tool set already up-to-date (model=${persistedEmbeddingModel}, hash=${expectedToolSetHash.substring(0, 12)})`);
+                        logger.log(`[Embedding] [${serverName}] Skipping — tool set already up-to-date (model=${persistedEmbeddingModel}, hash=${expectedToolSetHash.substring(0, 12)})`);
                         return;
                     }
-                    console.log(`[Embedding] [${serverName}] Generating embeddings: existing=${existingCount}, expected=${tools.length} (model=${persistedEmbeddingModel}, hash=${expectedToolSetHash.substring(0, 12)})`);
+                    logger.log(`[Embedding] [${serverName}] Generating embeddings: existing=${existingCount}, expected=${tools.length} (model=${persistedEmbeddingModel}, hash=${expectedToolSetHash.substring(0, 12)})`);
                 }
             }
             catch (skipCheckError) {
-                console.warn(`[Embedding] [${serverName}] Skip check failed, proceeding with full sync: ${skipCheckError?.message ?? skipCheckError}`);
+                logger.warn(`[Embedding] [${serverName}] Skip check failed, proceeding with full sync: ${skipCheckError?.message ?? skipCheckError}`);
             }
         }
         // ── Phase 1: Generate all embeddings in memory (no DB access) ──────────────
@@ -946,7 +960,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
             ]
                 .filter(Boolean)
                 .join(' ');
-            console.debug(`[Embedding] [${serverName}] Tool ${_toolIdx + 1}/${tools.length}: "${tool.name}" | raw text: ${searchableText.length} chars | preview: "${searchableText.substring(0, 200).replace(/\s+/g, ' ')}"`);
+            logger.debug(`[Embedding] [${serverName}] Tool ${_toolIdx + 1}/${tools.length}: "${tool.name}" | raw text: ${searchableText.length} chars | preview: "${searchableText.substring(0, 200).replace(/\s+/g, ' ')}"`);
             try {
                 const embedding = await generateEmbedding(searchableText);
                 toolEmbeddings.push({ tool, searchableText, embedding });
@@ -954,7 +968,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
             }
             catch (error) {
                 const status = extractErrorStatus(error);
-                console.warn('[EMBED_SYNC_ERROR] Failed while embedding tool', {
+                logger.warn('[EMBED_SYNC_ERROR] Failed while embedding tool', {
                     serverName,
                     toolName: tool.name,
                     status: status ?? 'unknown',
@@ -970,7 +984,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
         }
         catch (error) {
             const status = extractErrorStatus(error);
-            console.warn('[EMBED_SYNC_ERROR] Failed while embedding server metadata', {
+            logger.warn('[EMBED_SYNC_ERROR] Failed while embedding server metadata', {
                 serverName,
                 status: status ?? 'unknown',
                 error: summarizeErrorForLogging(error),
@@ -982,7 +996,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
         // Probe the connection before writing; reconnect if it went stale during the
         // (potentially long) embedding-generation phase above.
         if (!isDatabaseConnected()) {
-            console.info('Database connection lost during embedding generation, reinitializing...');
+            logger.info('Database connection lost during embedding generation, reinitializing...');
             await initializeDatabase();
         }
         else {
@@ -990,7 +1004,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
                 await getAppDataSource().query('SELECT 1');
             }
             catch {
-                console.warn('DB connection stale after embedding generation for server %s — reconnecting...', serverName);
+                logger.warn('DB connection stale after embedding generation for server %s — reconnecting...', serverName);
                 await reconnectDatabase();
             }
         }
@@ -1016,7 +1030,7 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
             const currentContentIds = toolEmbeddings.map(({ tool }) => `${serverName}:${tool.name}`);
             const staleCount = await vectorRepository.deleteStaleToolEmbeddings(serverName, currentContentIds, persistedEmbeddingModel);
             if (staleCount > 0) {
-                console.log(`[Embedding] [${serverName}] Removed ${staleCount} stale tool embedding(s)`);
+                logger.log(`[Embedding] [${serverName}] Removed ${staleCount} stale tool embedding(s)`);
             }
         }
         await vectorRepository.saveEmbedding('server', serverName, serverSearchableText, serverEmbedding, {
@@ -1027,13 +1041,13 @@ export const saveToolsAsVectorEmbeddings = async (serverName, tools, options = {
         if (vectorDimensionsReset) {
             scheduleFullEmbeddingResync(`Vector dimensions changed while syncing server "${serverName}"`);
         }
-        console.log('Saved tool embeddings', safeStringify({ serverName, toolCount: tools.length }));
+        logger.log('Saved tool embeddings', safeStringify({ serverName, toolCount: tools.length }));
     }
     catch (error) {
         if (shouldReport && !progressErrorEmitted) {
             emitProgress(lastProgressCurrent, 'error');
         }
-        console.error('Error saving tool embeddings', safeStringify({ serverName, error }));
+        logger.error('Error saving tool embeddings', safeStringify({ serverName, error }));
         throw error;
     }
 };
@@ -1114,7 +1128,7 @@ export const searchToolsByVector = async (query, limit = 10, threshold = 0.7, se
             .sort((a, b) => b.similarity - a.similarity);
     }
     catch (error) {
-        console.error('Error searching tools by vector', safeStringify({ query, limit, threshold, error }));
+        logger.error('Error searching tools by vector', safeStringify({ query, limit, threshold, error }));
         return [];
     }
 };
@@ -1148,7 +1162,7 @@ export const getAllVectorizedTools = async (serverNames) => {
             }
         }
         catch (error) {
-            console.warn('Could not determine vector dimensions from database', {
+            logger.warn('Could not determine vector dimensions from database', {
                 error: error?.message,
             });
         }
@@ -1186,7 +1200,7 @@ export const getAllVectorizedTools = async (serverNames) => {
                     };
                 }
                 catch (error) {
-                    console.error('Error parsing vector embedding metadata string', safeStringify({ error }));
+                    logger.error('Error parsing vector embedding metadata string', safeStringify({ error }));
                     return {
                         serverName: 'unknown',
                         toolName: 'unknown',
@@ -1204,7 +1218,7 @@ export const getAllVectorizedTools = async (serverNames) => {
         });
     }
     catch (error) {
-        console.error('Error getting all vectorized tools', safeStringify({ error, serverNames }));
+        logger.error('Error getting all vectorized tools', safeStringify({ error, serverNames }));
         return [];
     }
 };
@@ -1216,22 +1230,22 @@ export const removeServerToolEmbeddings = async (serverName) => {
     try {
         const smartRoutingConfig = await getSmartRoutingConfig();
         if (!smartRoutingConfig.dbUrl && !process.env.DB_URL) {
-            console.warn('Skipping embedding cleanup because DB URL is not configured', {
+            logger.warn('Skipping embedding cleanup because DB URL is not configured', {
                 serverName,
             });
             return;
         }
         // Ensure database is initialized before using repository
         if (!isDatabaseConnected()) {
-            console.info('Database not initialized, initializing...');
+            logger.info('Database not initialized, initializing...');
             await initializeDatabase();
         }
         const vectorRepository = getRepositoryFactory('vectorEmbeddings')();
         const removedCount = await vectorRepository.deleteByServerName(serverName);
-        console.log('Removed server embeddings', safeStringify({ serverName, removedCount }));
+        logger.log('Removed server embeddings', safeStringify({ serverName, removedCount }));
     }
     catch (error) {
-        console.error('Error removing server embeddings', safeStringify({ serverName, error }));
+        logger.error('Error removing server embeddings', safeStringify({ serverName, error }));
     }
 };
 /**
@@ -1240,7 +1254,7 @@ export const removeServerToolEmbeddings = async (serverName) => {
  */
 export const syncAllServerToolsEmbeddings = async () => {
     try {
-        console.log('Starting synchronization of all server tool embeddings');
+        logger.log('Starting synchronization of all server tool embeddings');
         // Import getServersInfo to get all server information
         const { getServersInfo } = await import('./mcpService.js');
         const servers = await getServersInfo();
@@ -1249,7 +1263,7 @@ export const syncAllServerToolsEmbeddings = async () => {
         for (const server of servers) {
             if (server.status === 'connected' && server.tools && server.tools.length > 0) {
                 try {
-                    console.log('Syncing tool embeddings for server', {
+                    logger.log('Syncing tool embeddings for server', {
                         serverName: server.name,
                         toolCount: server.tools.length,
                     });
@@ -1258,30 +1272,30 @@ export const syncAllServerToolsEmbeddings = async () => {
                     serversSynced++;
                 }
                 catch (error) {
-                    console.warn(`[EMBED_SYNC_ERROR] Failed to sync tool embeddings for server "${server.name}"`);
-                    console.error('Failed to sync tool embeddings for server', safeStringify({
+                    logger.warn(`[EMBED_SYNC_ERROR] Failed to sync tool embeddings for server "${server.name}"`);
+                    logger.error('Failed to sync tool embeddings for server', safeStringify({
                         serverName: server.name,
                         error,
                     }));
                 }
             }
             else if (server.status === 'connected' && (!server.tools || server.tools.length === 0)) {
-                console.log('Connected server has no tools to sync', safeStringify({ serverName: server.name }));
+                logger.log('Connected server has no tools to sync', safeStringify({ serverName: server.name }));
             }
             else {
-                console.log('Skipping server during tool embedding sync', {
+                logger.log('Skipping server during tool embedding sync', {
                     serverName: server.name,
                     status: server.status,
                 });
             }
         }
-        console.log('Completed smart routing tool embedding sync', {
+        logger.log('Completed smart routing tool embedding sync', {
             totalToolsSynced,
             serversSynced,
         });
     }
     catch (error) {
-        console.error('Error during smart routing tool embedding synchronization', { error });
+        logger.error('Error during smart routing tool embedding synchronization', { error });
         throw error;
     }
 };
@@ -1294,7 +1308,7 @@ async function checkDatabaseVectorDimensions(dimensionsNeeded) {
     try {
         // First check if database is initialized
         if (!getAppDataSource().isInitialized) {
-            console.info('Database not initialized, initializing...');
+            logger.info('Database not initialized, initializing...');
             await initializeDatabase();
         }
         // Check current vector dimension in the database
@@ -1311,7 +1325,7 @@ async function checkDatabaseVectorDimensions(dimensionsNeeded) {
       `);
         }
         catch (error) {
-            console.warn('Could not get vector type info, falling back to atttypmod query');
+            logger.warn('Could not get vector type info, falling back to atttypmod query');
         }
         // Fallback to original query
         const result = await getAppDataSource().query(`
@@ -1360,19 +1374,19 @@ async function checkDatabaseVectorDimensions(dimensionsNeeded) {
             }
         }
         catch (error) {
-            console.warn('Could not check vector dimensions from actual records', { error });
+            logger.warn('Could not check vector dimensions from actual records', { error });
         }
         // If no dimensions are set or they don't match what we need, handle the mismatch
         if (currentDimensions === 0 || currentDimensions !== dimensionsNeeded) {
-            console.log('Vector dimensions mismatch detected', {
+            logger.log('Vector dimensions mismatch detected', {
                 currentDimensions,
                 dimensionsNeeded,
             });
             if (currentDimensions === 0) {
-                console.log('Setting up vector dimensions for the first time...');
+                logger.log('Setting up vector dimensions for the first time...');
             }
             else {
-                console.log('Dimension mismatch detected. Clearing existing incompatible vector data...');
+                logger.log('Dimension mismatch detected. Clearing existing incompatible vector data...');
                 // Clear all existing vector embeddings with mismatched dimensions
                 await clearMismatchedVectorData(dimensionsNeeded);
             }
@@ -1387,14 +1401,14 @@ async function checkDatabaseVectorDimensions(dimensionsNeeded) {
                 await getAppDataSource().query(`DROP INDEX IF EXISTS idx_vector_embeddings_embedding;`);
             }
             catch (dropError) {
-                console.warn('Could not drop existing vector index before ALTER', {
+                logger.warn('Could not drop existing vector index before ALTER', {
                     error: dropError?.message,
                 });
             }
             // Alter the column type with the new dimensions
             // Use halfvec for dimensions > 2000, vector otherwise
             const vectorType = dimensionsNeeded <= VECTOR_MAX_DIMENSIONS ? 'vector' : 'halfvec';
-            console.log('Using vector storage type for configured dimensions', {
+            logger.log('Using vector storage type for configured dimensions', {
                 vectorType,
                 dimensionsNeeded,
             });
@@ -1405,9 +1419,9 @@ async function checkDatabaseVectorDimensions(dimensionsNeeded) {
             // Create appropriate vector index using the helper function
             const result = await createVectorIndex(getAppDataSource(), dimensionsNeeded);
             if (!result.success) {
-                console.log('Continuing without optimized vector index...');
+                logger.log('Continuing without optimized vector index...');
             }
-            console.log('Successfully configured vector dimensions', { dimensionsNeeded });
+            logger.log('Successfully configured vector dimensions', { dimensionsNeeded });
             // Only signal that a full resync is needed when existing data was cleared due
             // to a real dimension change. When currentDimensions === 0 it is a first-time
             // setup — there are no stale embeddings to re-generate.
@@ -1416,7 +1430,7 @@ async function checkDatabaseVectorDimensions(dimensionsNeeded) {
         return false;
     }
     catch (error) {
-        console.error('Error checking or updating vector dimensions', { error });
+        logger.error('Error checking or updating vector dimensions', { error });
         throw new Error(`Vector dimension check failed: ${error?.message || 'Unknown error'}`);
     }
 }
@@ -1427,16 +1441,16 @@ async function checkDatabaseVectorDimensions(dimensionsNeeded) {
  */
 async function clearMismatchedVectorData(expectedDimensions) {
     try {
-        console.log(`Clearing vector embeddings with dimensions different from ${expectedDimensions}...`);
+        logger.log(`Clearing vector embeddings with dimensions different from ${expectedDimensions}...`);
         // Delete all embeddings that don't match the expected dimensions
         await getAppDataSource().query(`
       DELETE FROM vector_embeddings 
       WHERE dimensions != $1
     `, [expectedDimensions]);
-        console.log('Successfully cleared mismatched vector embeddings');
+        logger.log('Successfully cleared mismatched vector embeddings');
     }
     catch (error) {
-        console.error('Error clearing mismatched vector data:', error);
+        logger.error('Error clearing mismatched vector data:', error);
         throw error;
     }
 }