@mhalder/qdrant-mcp-server 3.2.0 → 3.3.0

package/src/index.ts

@@ -8,6 +8,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import Bottleneck from "bottleneck";
 import express from "express";
+import logger from "./logger.js";
 import {
   DEFAULT_BATCH_SIZE,
   DEFAULT_CHUNK_OVERLAP,
@@ -47,8 +48,9 @@ const PROMPTS_CONFIG_FILE =
 // Validate HTTP_PORT when HTTP mode is selected
 if (TRANSPORT_MODE === "http") {
   if (Number.isNaN(HTTP_PORT) || HTTP_PORT < 1 || HTTP_PORT > 65535) {
-    console.error(
-      `Error: Invalid HTTP_PORT "${process.env.HTTP_PORT}". Must be a number between 1 and 65535.`,
+    logger.fatal(
+      { port: process.env.HTTP_PORT },
+      "Invalid HTTP_PORT. Must be a number between 1 and 65535",
     );
     process.exit(1);
   }
@@ -73,15 +75,17 @@ if (EMBEDDING_PROVIDER !== "ollama") {
       requiredKeyName = "VOYAGE_API_KEY";
       break;
     default:
-      console.error(
-        `Error: Unknown embedding provider "${EMBEDDING_PROVIDER}". Supported providers: openai, cohere, voyage, ollama.`,
+      logger.fatal(
+        { provider: EMBEDDING_PROVIDER },
+        "Unknown embedding provider. Supported providers: openai, cohere, voyage, ollama",
       );
       process.exit(1);
   }
 
   if (!apiKey) {
-    console.error(
-      `Error: ${requiredKeyName} is required for ${EMBEDDING_PROVIDER} provider.`,
+    logger.fatal(
+      { provider: EMBEDDING_PROVIDER, requiredKey: requiredKeyName },
+      `${requiredKeyName} is required for ${EMBEDDING_PROVIDER} provider`,
     );
     process.exit(1);
   }
@@ -123,14 +127,14 @@ async function checkOllamaAvailability() {
             `  ollama pull ${modelName}`;
         }
 
-        console.error(errorMessage);
+        logger.fatal({ model: modelName }, errorMessage);
         process.exit(1);
       }
     } catch (error) {
       const errorMessage =
         error instanceof Error
-          ? `Error: ${error.message}`
-          : `Error: Ollama is not running at ${baseUrl}.\n`;
+          ? error.message
+          : `Ollama is not running at ${baseUrl}`;
 
       let helpText = "";
       if (isLocalhost) {
@@ -149,7 +153,7 @@ async function checkOllamaAvailability() {
           `  - The embedding model is available (e.g., nomic-embed-text)`;
       }
 
-      console.error(`${errorMessage}\n${helpText}`);
+      logger.fatal({ baseUrl, err: error }, `${errorMessage}\n${helpText}`);
       process.exit(1);
     }
   }
@@ -157,7 +161,17 @@ async function checkOllamaAvailability() {
 
 // Initialize clients
 const qdrant = new QdrantManager(QDRANT_URL, QDRANT_API_KEY);
+logger.info({ url: QDRANT_URL }, "Qdrant client initialized");
+
 const embeddings = EmbeddingProviderFactory.createFromEnv();
+logger.info(
+  {
+    provider: EMBEDDING_PROVIDER,
+    model: embeddings.getModel(),
+    dimensions: embeddings.getDimensions(),
+  },
+  "Embedding provider initialized",
+);
 
 // Initialize code indexer
 const codeConfig: CodeConfig = {
@@ -184,6 +198,7 @@ const codeConfig: CodeConfig = {
 };
 
 const codeIndexer = new CodeIndexer(qdrant, embeddings, codeConfig);
+logger.debug({ codeConfig }, "Code indexer configured");
 
 // Initialize git history indexer
 const gitConfig: GitConfig = {
@@ -223,19 +238,21 @@ const gitConfig: GitConfig = {
 };
 
 const gitHistoryIndexer = new GitHistoryIndexer(qdrant, embeddings, gitConfig);
+logger.debug({ gitConfig }, "Git history indexer configured");
 
 // Load prompts configuration if file exists
 let promptsConfig: PromptsConfig | null = null;
 if (existsSync(PROMPTS_CONFIG_FILE)) {
   try {
     promptsConfig = loadPromptsConfig(PROMPTS_CONFIG_FILE);
-    console.error(
-      `Loaded ${promptsConfig.prompts.length} prompts from ${PROMPTS_CONFIG_FILE}`,
+    logger.info(
+      { count: promptsConfig.prompts.length, file: PROMPTS_CONFIG_FILE },
+      "Loaded prompts config",
     );
   } catch (error) {
-    console.error(
-      `Failed to load prompts configuration from ${PROMPTS_CONFIG_FILE}:`,
-      error,
+    logger.fatal(
+      { file: PROMPTS_CONFIG_FILE, err: error },
+      "Failed to load prompts configuration",
     );
     process.exit(1);
   }
@@ -265,7 +282,7 @@ function createAndConfigureServer(): McpServer {
 
     return server;
   } catch (error) {
-    console.error("Failed to configure MCP server:", error);
+    logger.error({ err: error }, "Failed to configure MCP server");
     throw error;
   }
 }
@@ -278,7 +295,7 @@ async function startStdioServer() {
   await checkOllamaAvailability();
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("Qdrant MCP server running on stdio");
+  logger.info("Qdrant MCP server running on stdio");
 }
 
 // Constants for HTTP server configuration
@@ -294,8 +311,9 @@ const SHUTDOWN_GRACE_PERIOD_MS = 10 * 1000; // 10 seconds
 
 // Validate REQUEST_TIMEOUT_MS
 if (Number.isNaN(REQUEST_TIMEOUT_MS) || REQUEST_TIMEOUT_MS <= 0) {
-  console.error(
-    `Error: Invalid HTTP_REQUEST_TIMEOUT_MS "${process.env.HTTP_REQUEST_TIMEOUT_MS}". Must be a positive integer.`,
+  logger.fatal(
+    { value: process.env.HTTP_REQUEST_TIMEOUT_MS },
+    "Invalid HTTP_REQUEST_TIMEOUT_MS. Must be a positive integer",
   );
   process.exit(1);
 }
@@ -354,7 +372,10 @@ async function startHttpServer() {
     });
 
     if (keysToDelete.length > 0) {
-      console.error(`Cleaned up ${keysToDelete.length} inactive rate limiters`);
+      logger.debug(
+        { count: keysToDelete.length },
+        "Cleaned up inactive rate limiters",
+      );
     }
   }, RATE_LIMITER_CLEANUP_INTERVAL_MS);
 
@@ -377,9 +398,12 @@ async function startHttpServer() {
     } catch (error) {
       // Differentiate between rate limit errors and unexpected errors
       if (error instanceof Bottleneck.BottleneckError) {
-        console.error(`Rate limit exceeded for IP ${clientIp}:`, error.message);
+        logger.warn({ clientIp }, "Rate limit exceeded");
       } else {
-        console.error("Unexpected rate limiting error:", error);
+        logger.error(
+          { clientIp, err: error },
+          "Unexpected rate limiting error",
+        );
       }
       sendErrorResponse(res, -32000, "Too many requests", 429);
     }
@@ -418,7 +442,7 @@ async function startHttpServer() {
     const timeoutId = setTimeout(() => {
       sendErrorResponse(res, -32000, "Request timeout", 504);
       cleanup().catch((err) => {
-        console.error("Error during timeout cleanup:", err);
+        logger.error({ err }, "Error during timeout cleanup");
       });
     }, REQUEST_TIMEOUT_MS);
 
@@ -435,19 +459,19 @@ async function startHttpServer() {
       const cleanupHandler = () => {
         clearTimeout(timeoutId);
         cleanup().catch((err) => {
-          console.error("Error during response cleanup:", err);
+          logger.error({ err }, "Error during response cleanup");
         });
       };
 
       res.on("finish", cleanupHandler);
       res.on("close", cleanupHandler);
       res.on("error", (err) => {
-        console.error("Response stream error:", err);
+        logger.error({ err }, "Response stream error");
         cleanupHandler();
       });
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error("Error handling MCP request:", error);
+      logger.error({ err: error }, "Error handling MCP request");
       sendErrorResponse(res, -32603, "Internal server error");
       await cleanup();
     }
@@ -455,12 +479,10 @@ async function startHttpServer() {
 
   const httpServer = app
     .listen(HTTP_PORT, () => {
-      console.error(
-        `Qdrant MCP server running on http://localhost:${HTTP_PORT}/mcp`,
-      );
+      logger.info({ port: HTTP_PORT }, "Qdrant MCP server running on HTTP");
     })
     .on("error", (error) => {
-      console.error("HTTP server error:", error);
+      logger.fatal({ err: error }, "HTTP server error");
       process.exit(1);
     });
 
@@ -471,22 +493,20 @@ async function startHttpServer() {
     if (isShuttingDown) return;
     isShuttingDown = true;
 
-    console.error(
-      "Shutdown signal received, closing HTTP server gracefully...",
-    );
+    logger.info("Shutdown signal received, closing HTTP server gracefully");
 
     // Clear the cleanup interval to allow graceful shutdown
     clearInterval(cleanupIntervalId);
 
     // Force shutdown after grace period
     const forceTimeout = setTimeout(() => {
-      console.error("Forcing shutdown after timeout");
+      logger.warn("Forcing shutdown after timeout");
       process.exit(1);
     }, SHUTDOWN_GRACE_PERIOD_MS);
 
     httpServer.close(() => {
       clearTimeout(forceTimeout);
-      console.error("HTTP server closed");
+      logger.info("HTTP server closed");
       process.exit(0);
     });
   };
@@ -502,14 +522,15 @@ async function main() {
   } else if (TRANSPORT_MODE === "stdio") {
     await startStdioServer();
   } else {
-    console.error(
-      `Error: Invalid TRANSPORT_MODE "${TRANSPORT_MODE}". Supported modes: stdio, http.`,
+    logger.fatal(
+      { mode: TRANSPORT_MODE },
+      "Invalid TRANSPORT_MODE. Supported modes: stdio, http",
     );
     process.exit(1);
   }
 }
 
 main().catch((error) => {
-  console.error("Fatal error:", error);
+  logger.fatal({ err: error }, "Fatal error");
   process.exit(1);
 });

package/src/logger.ts

@@ -0,0 +1,33 @@
+import pino from "pino";
+
+const VALID_LEVELS = [
+  "fatal",
+  "error",
+  "warn",
+  "info",
+  "debug",
+  "trace",
+  "silent",
+];
+
+function resolveLogLevel(): string {
+  const level = process.env.LOG_LEVEL?.toLowerCase();
+  if (!level) return "info";
+
+  if (VALID_LEVELS.includes(level)) {
+    return level;
+  }
+
+  // Write warning directly to stderr since logger isn't initialized yet
+  process.stderr.write(
+    `WARNING: Invalid LOG_LEVEL "${process.env.LOG_LEVEL}". Valid levels: ${VALID_LEVELS.join(", ")}. Falling back to "info".\n`,
+  );
+  return "info";
+}
+
+const logger = pino(
+  { level: resolveLogLevel(), name: "qdrant-mcp" },
+  pino.destination(2),
+);
+
+export default logger;

package/src/qdrant/client.test.ts

@@ -20,6 +20,18 @@ vi.mock("@qdrant/js-client-rest", () => ({
   }),
 }));
 
+vi.mock("../logger.js", () => ({
+  default: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+    fatal: vi.fn(),
+    trace: vi.fn(),
+    child: vi.fn().mockReturnThis(),
+  },
+}));
+
 describe("QdrantManager", () => {
   let manager: QdrantManager;
 

package/src/qdrant/client.ts

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { QdrantClient } from "@qdrant/js-client-rest";
+import logger from "../logger.js";
 
 export interface CollectionInfo {
   name: string;
@@ -21,6 +22,7 @@ export interface SparseVector {
 }
 
 export class QdrantManager {
+  private log = logger.child({ component: "qdrant" });
   private client: QdrantClient;
 
   constructor(url: string = "http://localhost:6333", apiKey?: string) {
@@ -54,6 +56,10 @@ export class QdrantManager {
     distance: "Cosine" | "Euclid" | "Dot" = "Cosine",
     enableSparse: boolean = false,
   ): Promise<void> {
+    this.log.debug(
+      { collection: name, vectorSize, distance, enableSparse },
+      "createCollection",
+    );
     const config: any = {};
 
     // When hybrid search is enabled, use named vectors
@@ -131,6 +137,7 @@ export class QdrantManager {
   }
 
   async deleteCollection(name: string): Promise<void> {
+    this.log.debug({ collection: name }, "deleteCollection");
     await this.client.deleteCollection(name);
   }
 
@@ -142,6 +149,10 @@ export class QdrantManager {
       payload?: Record<string, any>;
     }>,
   ): Promise<void> {
+    this.log.debug(
+      { collection: collectionName, count: points.length },
+      "addPoints",
+    );
     try {
       // Normalize all IDs to ensure string IDs are in UUID format
       const normalizedPoints = points.map((point) => ({
@@ -168,6 +179,7 @@ export class QdrantManager {
     limit: number = 5,
     filter?: Record<string, any>,
   ): Promise<SearchResult[]> {
+    this.log.debug({ collection: collectionName, limit }, "search");
     // Convert simple key-value filter to Qdrant filter format
     // Accepts either:
     // 1. Simple format: {"category": "database"}
@@ -231,6 +243,10 @@ export class QdrantManager {
     collectionName: string,
     ids: (string | number)[],
   ): Promise<void> {
+    this.log.debug(
+      { collection: collectionName, count: ids.length },
+      "deletePoints",
+    );
     // Normalize IDs to ensure string IDs are in UUID format
     const normalizedIds = ids.map((id) => this.normalizeId(id));
 
@@ -248,6 +264,7 @@ export class QdrantManager {
     collectionName: string,
     filter: Record<string, any>,
   ): Promise<void> {
+    this.log.debug({ collection: collectionName }, "deletePointsByFilter");
     await this.client.delete(collectionName, {
       wait: true,
       filter: filter,
@@ -266,6 +283,7 @@ export class QdrantManager {
     filter?: Record<string, any>,
     _semanticWeight: number = 0.7,
   ): Promise<SearchResult[]> {
+    this.log.debug({ collection: collectionName, limit }, "hybridSearch");
     // Convert simple key-value filter to Qdrant filter format
     let qdrantFilter;
     if (filter && Object.keys(filter).length > 0) {
@@ -334,6 +352,10 @@ export class QdrantManager {
       payload?: Record<string, any>;
     }>,
   ): Promise<void> {
+    this.log.debug(
+      { collection: collectionName, count: points.length },
+      "addPointsWithSparse",
+    );
     try {
       // Normalize all IDs to ensure string IDs are in UUID format
       const normalizedPoints = points.map((point) => ({

package/src/tools/code.ts

@@ -3,9 +3,13 @@
  */
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import logger from "../logger.js";
 import type { CodeIndexer } from "../code/indexer.js";
+import { withToolLogging } from "./logging.js";
 import * as schemas from "./schemas.js";
 
+const log = logger.child({ component: "tools" });
+
 export interface CodeToolDependencies {
   codeIndexer: CodeIndexer;
 }
@@ -25,31 +29,48 @@ export function registerCodeTools(
         "Index a codebase for semantic code search. Automatically discovers files, chunks code intelligently using AST-aware parsing, and stores in vector database. Respects .gitignore and other ignore files.",
       inputSchema: schemas.IndexCodebaseSchema,
     },
-    async ({ path, forceReindex, extensions, ignorePatterns }) => {
-      const stats = await codeIndexer.indexCodebase(
-        path,
-        { forceReindex, extensions, ignorePatterns },
-        (progress) => {
-          // Progress callback - could send progress updates via SSE in future
-          console.error(
-            `[${progress.phase}] ${progress.percentage}% - ${progress.message}`,
-          );
-        },
-      );
-
-      let statusMessage = `Indexed ${stats.filesIndexed}/${stats.filesScanned} files (${stats.chunksCreated} chunks) in ${(stats.durationMs / 1000).toFixed(1)}s`;
-
-      if (stats.status === "partial") {
-        statusMessage += `\n\nWarnings:\n${stats.errors?.join("\n")}`;
-      } else if (stats.status === "failed") {
-        statusMessage = `Indexing failed:\n${stats.errors?.join("\n")}`;
-      }
+    withToolLogging(
+      "index_codebase",
+      async ({ path, forceReindex, extensions, ignorePatterns }, extra) => {
+        log.info({ tool: "index_codebase", path, forceReindex }, "Tool called");
+        const progressToken = extra._meta?.progressToken;
+
+        const stats = await codeIndexer.indexCodebase(
+          path,
+          { forceReindex, extensions, ignorePatterns },
+          (progress) => {
+            log.debug(
+              { phase: progress.phase, percentage: progress.percentage },
+              progress.message,
+            );
+            if (progressToken !== undefined) {
+              extra.sendNotification({
+                method: "notifications/progress",
+                params: {
+                  progressToken,
+                  progress: progress.percentage,
+                  total: 100,
+                  message: `[${progress.phase}] ${progress.message}`,
+                },
+              });
+            }
+          },
+        );
 
-      return {
-        content: [{ type: "text", text: statusMessage }],
-        isError: stats.status === "failed",
-      };
-    },
+        let statusMessage = `Indexed ${stats.filesIndexed}/${stats.filesScanned} files (${stats.chunksCreated} chunks) in ${(stats.durationMs / 1000).toFixed(1)}s`;
+
+        if (stats.status === "partial") {
+          statusMessage += `\n\nWarnings:\n${stats.errors?.join("\n")}`;
+        } else if (stats.status === "failed") {
+          statusMessage = `Indexing failed:\n${stats.errors?.join("\n")}`;
+        }
+
+        return {
+          content: [{ type: "text", text: statusMessage }],
+          isError: stats.status === "failed",
+        };
+      },
+    ),
   );
 
   // search_code
@@ -61,41 +82,48 @@ export function registerCodeTools(
         "Search indexed codebase using natural language queries. Returns semantically relevant code chunks with file paths and line numbers.",
       inputSchema: schemas.SearchCodeSchema,
     },
-    async ({ path, query, limit, fileTypes, pathPattern }) => {
-      const results = await codeIndexer.searchCode(path, query, {
-        limit,
-        fileTypes,
-        pathPattern,
-      });
+    withToolLogging(
+      "search_code",
+      async ({ path, query, limit, fileTypes, pathPattern }) => {
+        log.info(
+          { tool: "search_code", path, query: query.substring(0, 80) },
+          "Tool called",
+        );
+        const results = await codeIndexer.searchCode(path, query, {
+          limit,
+          fileTypes,
+          pathPattern,
+        });
+
+        if (results.length === 0) {
+          return {
+            content: [
+              { type: "text", text: `No results found for query: "${query}"` },
+            ],
+          };
+        }
+
+        // Format results with file references
+        const formattedResults = results
+          .map(
+            (r, idx) =>
+              `\n--- Result ${idx + 1} (score: ${r.score.toFixed(3)}) ---\n` +
+              `File: ${r.filePath}:${r.startLine}-${r.endLine}\n` +
+              `Language: ${r.language}\n\n` +
+              `${r.content}\n`,
+          )
+          .join("\n");
 
-      if (results.length === 0) {
         return {
           content: [
-            { type: "text", text: `No results found for query: "${query}"` },
+            {
+              type: "text",
+              text: `Found ${results.length} result(s):\n${formattedResults}`,
+            },
           ],
         };
-      }
-
-      // Format results with file references
-      const formattedResults = results
-        .map(
-          (r, idx) =>
-            `\n--- Result ${idx + 1} (score: ${r.score.toFixed(3)}) ---\n` +
-            `File: ${r.filePath}:${r.startLine}-${r.endLine}\n` +
-            `Language: ${r.language}\n\n` +
-            `${r.content}\n`,
-        )
-        .join("\n");
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Found ${results.length} result(s):\n${formattedResults}`,
-          },
-        ],
-      };
-    },
+      },
+    ),
   );
 
   // reindex_changes
@@ -107,11 +135,26 @@ export function registerCodeTools(
         "Incrementally re-index only changed files. Detects added, modified, and deleted files since last index. Requires previous indexing with index_codebase.",
       inputSchema: schemas.ReindexChangesSchema,
     },
-    async ({ path }) => {
+    withToolLogging("reindex_changes", async ({ path }, extra) => {
+      log.info({ tool: "reindex_changes", path }, "Tool called");
+      const progressToken = extra._meta?.progressToken;
+
       const stats = await codeIndexer.reindexChanges(path, (progress) => {
-        console.error(
-          `[${progress.phase}] ${progress.percentage}% - ${progress.message}`,
+        log.debug(
+          { phase: progress.phase, percentage: progress.percentage },
+          progress.message,
         );
+        if (progressToken !== undefined) {
+          extra.sendNotification({
+            method: "notifications/progress",
+            params: {
+              progressToken,
+              progress: progress.percentage,
+              total: 100,
+              message: `[${progress.phase}] ${progress.message}`,
+            },
+          });
+        }
       });
 
       let message = `Incremental re-index complete:\n`;
@@ -132,7 +175,7 @@ export function registerCodeTools(
       return {
         content: [{ type: "text", text: message }],
       };
-    },
+    }),
   );
 
   // get_index_status
@@ -143,7 +186,8 @@ export function registerCodeTools(
       description: "Get indexing status and statistics for a codebase.",
       inputSchema: schemas.GetIndexStatusSchema,
     },
-    async ({ path }) => {
+    withToolLogging("get_index_status", async ({ path }) => {
+      log.info({ tool: "get_index_status", path }, "Tool called");
       const status = await codeIndexer.getIndexStatus(path);
 
       if (status.status === "not_indexed") {
@@ -171,7 +215,7 @@ export function registerCodeTools(
       return {
         content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
       };
-    },
+    }),
   );
 
   // clear_index
@@ -183,13 +227,14 @@ export function registerCodeTools(
         "Delete all indexed data for a codebase. This is irreversible and will remove the entire collection.",
       inputSchema: schemas.ClearIndexSchema,
     },
-    async ({ path }) => {
+    withToolLogging("clear_index", async ({ path }) => {
+      log.info({ tool: "clear_index", path }, "Tool called");
       await codeIndexer.clearIndex(path);
       return {
         content: [
           { type: "text", text: `Index cleared for codebase at "${path}".` },
         ],
       };
-    },
+    }),
   );
 }