@mhalder/qdrant-mcp-server 3.3.3 → 3.3.4

package/src/tools/schemas.ts

@@ -36,58 +36,40 @@ export const AddDocumentsSchema = {
   documents: z
     .array(
       z.object({
-        id: z
-          .union([z.string(), z.number()])
-          .describe("Unique identifier for the document"),
+        id: z.union([z.string(), z.number()]).describe("Unique identifier for the document"),
         text: z.string().describe("Text content to embed and store"),
         metadata: z
           .record(z.string(), z.any())
           .optional()
           .describe("Optional metadata to store with the document"),
-      }),
+      })
     )
     .describe("Array of documents to add"),
 };
 
 export const DeleteDocumentsSchema = {
   collection: z.string().describe("Name of the collection"),
-  ids: z
-    .array(z.union([z.string(), z.number()]))
-    .describe("Array of document IDs to delete"),
+  ids: z.array(z.union([z.string(), z.number()])).describe("Array of document IDs to delete"),
 };
 
 // Search schemas
 export const SemanticSearchSchema = {
   collection: z.string().describe("Name of the collection to search"),
   query: z.string().describe("Search query text"),
-  limit: z
-    .number()
-    .optional()
-    .describe("Maximum number of results (default: 5)"),
-  filter: z
-    .record(z.string(), z.any())
-    .optional()
-    .describe("Optional metadata filter"),
+  limit: z.number().optional().describe("Maximum number of results (default: 5)"),
+  filter: z.record(z.string(), z.any()).optional().describe("Optional metadata filter"),
 };
 
 export const HybridSearchSchema = {
   collection: z.string().describe("Name of the collection to search"),
   query: z.string().describe("Search query text"),
-  limit: z
-    .number()
-    .optional()
-    .describe("Maximum number of results (default: 5)"),
-  filter: z
-    .record(z.string(), z.any())
-    .optional()
-    .describe("Optional metadata filter"),
+  limit: z.number().optional().describe("Maximum number of results (default: 5)"),
+  filter: z.record(z.string(), z.any()).optional().describe("Optional metadata filter"),
 };
 
 // Code indexing schemas
 export const IndexCodebaseSchema = {
-  path: z
-    .string()
-    .describe("Absolute or relative path to codebase root directory"),
+  path: z.string().describe("Absolute or relative path to codebase root directory"),
   forceReindex: z
     .boolean()
     .optional()
@@ -99,20 +81,13 @@ export const IndexCodebaseSchema = {
   ignorePatterns: z
     .array(z.string())
     .optional()
-    .describe(
-      "Additional patterns to ignore (e.g., ['**/test/**', '**/*.test.ts'])",
-    ),
+    .describe("Additional patterns to ignore (e.g., ['**/test/**', '**/*.test.ts'])"),
 };
 
 export const SearchCodeSchema = {
   path: z.string().describe("Path to codebase (must be indexed first)"),
-  query: z
-    .string()
-    .describe("Natural language search query (e.g., 'authentication logic')"),
-  limit: z
-    .number()
-    .optional()
-    .describe("Maximum number of results (default: 5, max: 100)"),
+  query: z.string().describe("Natural language search query (e.g., 'authentication logic')"),
+  limit: z.number().optional().describe("Maximum number of results (default: 5, max: 100)"),
   fileTypes: z
     .array(z.string())
     .optional()
@@ -145,26 +120,16 @@ export const IndexGitHistorySchema = {
   sinceDate: z
     .string()
     .optional()
-    .describe(
-      "Only index commits after this date (ISO format, e.g., '2024-01-01')",
-    ),
-  maxCommits: z
-    .number()
-    .optional()
-    .describe("Maximum number of commits to index (default: 5000)"),
+    .describe("Only index commits after this date (ISO format, e.g., '2024-01-01')"),
+  maxCommits: z.number().optional().describe("Maximum number of commits to index (default: 5000)"),
 };
 
 export const SearchGitHistorySchema = {
   path: z.string().describe("Path to git repository (must be indexed first)"),
   query: z
     .string()
-    .describe(
-      "Natural language search query (e.g., 'fix null pointer in authentication')",
-    ),
-  limit: z
-    .number()
-    .optional()
-    .describe("Maximum number of results (default: 10, max: 100)"),
+    .describe("Natural language search query (e.g., 'fix null pointer in authentication')"),
+  limit: z.number().optional().describe("Maximum number of results (default: 10, max: 100)"),
   commitTypes: z
     .array(
       z.enum([
@@ -180,22 +145,13 @@ export const SearchGitHistorySchema = {
         "ci",
         "revert",
         "other",
-      ]),
+      ])
     )
     .optional()
     .describe("Filter by commit type (e.g., ['fix', 'feat'])"),
-  authors: z
-    .array(z.string())
-    .optional()
-    .describe("Filter by author name or email"),
-  dateFrom: z
-    .string()
-    .optional()
-    .describe("Only commits after this date (ISO format)"),
-  dateTo: z
-    .string()
-    .optional()
-    .describe("Only commits before this date (ISO format)"),
+  authors: z.array(z.string()).optional().describe("Filter by author name or email"),
+  dateFrom: z.string().optional().describe("Only commits after this date (ISO format)"),
+  dateTo: z.string().optional().describe("Only commits before this date (ISO format)"),
 };
 
 export const IndexNewCommitsSchema = {
@@ -214,18 +170,10 @@ export const ClearGitIndexSchema = {
 export const ContextualSearchSchema = {
   path: z
     .string()
-    .describe(
-      "Path to git repository (must be indexed for both code and git history)",
-    ),
+    .describe("Path to git repository (must be indexed for both code and git history)"),
   query: z.string().describe("Natural language search query"),
-  codeLimit: z
-    .number()
-    .optional()
-    .describe("Maximum number of code results (default: 5)"),
-  gitLimit: z
-    .number()
-    .optional()
-    .describe("Maximum number of git history results (default: 5)"),
+  codeLimit: z.number().optional().describe("Maximum number of code results (default: 5)"),
+  gitLimit: z.number().optional().describe("Maximum number of git history results (default: 5)"),
   correlate: z
     .boolean()
     .optional()
@@ -239,10 +187,7 @@ export const FederatedSearchSchema = {
     .min(1)
     .describe("Array of repository paths to search (must all be indexed)"),
   query: z.string().describe("Natural language search query"),
-  searchType: z
-    .enum(["code", "git", "both"])
-    .optional()
-    .describe("Type of search (default: both)"),
+  searchType: z.enum(["code", "git", "both"]).optional().describe("Type of search (default: both)"),
   limit: z
     .number()
     .optional()

package/src/tools/search.ts

@@ -3,9 +3,9 @@
  */
 
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import logger from "../logger.js";
 import type { EmbeddingProvider } from "../embeddings/base.js";
 import { BM25SparseVectorGenerator } from "../embeddings/sparse.js";
+import logger from "../logger.js";
 import type { QdrantManager } from "../qdrant/client.js";
 import { withToolLogging } from "./logging.js";
 import * as schemas from "./schemas.js";
@@ -17,10 +17,7 @@ export interface SearchToolDependencies {
   embeddings: EmbeddingProvider;
 }
 
-export function registerSearchTools(
-  server: McpServer,
-  deps: SearchToolDependencies,
-): void {
+export function registerSearchTools(server: McpServer, deps: SearchToolDependencies): void {
   const { qdrant, embeddings } = deps;
 
   // semantic_search
@@ -32,47 +29,39 @@ export function registerSearchTools(
         "Search for documents using natural language queries. Returns the most semantically similar documents.",
       inputSchema: schemas.SemanticSearchSchema,
     },
-    withToolLogging(
-      "semantic_search",
-      async ({ collection, query, limit, filter }) => {
-        log.info(
-          {
-            tool: "semantic_search",
-            collection,
-            query: query.substring(0, 80),
-          },
-          "Tool called",
-        );
-        // Check if collection exists
-        const exists = await qdrant.collectionExists(collection);
-        if (!exists) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Collection "${collection}" does not exist.`,
-              },
-            ],
-            isError: true,
-          };
-        }
-
-        // Generate embedding for query
-        const { embedding } = await embeddings.embed(query);
-
-        // Search
-        const results = await qdrant.search(
+    withToolLogging("semantic_search", async ({ collection, query, limit, filter }) => {
+      log.info(
+        {
+          tool: "semantic_search",
           collection,
-          embedding,
-          limit || 5,
-          filter,
-        );
-
+          query: query.substring(0, 80),
+        },
+        "Tool called"
+      );
+      // Check if collection exists
+      const exists = await qdrant.collectionExists(collection);
+      if (!exists) {
         return {
-          content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+          content: [
+            {
+              type: "text",
+              text: `Error: Collection "${collection}" does not exist.`,
+            },
+          ],
+          isError: true,
         };
-      },
-    ),
+      }
+
+      // Generate embedding for query
+      const { embedding } = await embeddings.embed(query);
+
+      // Search
+      const results = await qdrant.search(collection, embedding, limit || 5, filter);
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+      };
+    })
   );
 
   // hybrid_search
@@ -84,61 +73,55 @@ export function registerSearchTools(
         "Perform hybrid search combining semantic vector search with keyword search using BM25. This provides better results by combining the strengths of both approaches. The collection must be created with enableHybrid set to true.",
       inputSchema: schemas.HybridSearchSchema,
     },
-    withToolLogging(
-      "hybrid_search",
-      async ({ collection, query, limit, filter }) => {
-        log.info(
-          { tool: "hybrid_search", collection, query: query.substring(0, 80) },
-          "Tool called",
-        );
-        // Check if collection exists
-        const exists = await qdrant.collectionExists(collection);
-        if (!exists) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Collection "${collection}" does not exist.`,
-              },
-            ],
-            isError: true,
-          };
-        }
+    withToolLogging("hybrid_search", async ({ collection, query, limit, filter }) => {
+      log.info({ tool: "hybrid_search", collection, query: query.substring(0, 80) }, "Tool called");
+      // Check if collection exists
+      const exists = await qdrant.collectionExists(collection);
+      if (!exists) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: Collection "${collection}" does not exist.`,
+            },
+          ],
+          isError: true,
+        };
+      }
 
-        // Check if collection has hybrid search enabled
-        const collectionInfo = await qdrant.getCollectionInfo(collection);
-        if (!collectionInfo.hybridEnabled) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: Collection "${collection}" does not have hybrid search enabled. Create a new collection with enableHybrid set to true.`,
-              },
-            ],
-            isError: true,
-          };
-        }
+      // Check if collection has hybrid search enabled
+      const collectionInfo = await qdrant.getCollectionInfo(collection);
+      if (!collectionInfo.hybridEnabled) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: Collection "${collection}" does not have hybrid search enabled. Create a new collection with enableHybrid set to true.`,
+            },
+          ],
+          isError: true,
+        };
+      }
 
-        // Generate dense embedding for query
-        const { embedding } = await embeddings.embed(query);
+      // Generate dense embedding for query
+      const { embedding } = await embeddings.embed(query);
 
-        // Generate sparse vector for query
-        const sparseGenerator = new BM25SparseVectorGenerator();
-        const sparseVector = sparseGenerator.generate(query);
+      // Generate sparse vector for query
+      const sparseGenerator = new BM25SparseVectorGenerator();
+      const sparseVector = sparseGenerator.generate(query);
 
-        // Perform hybrid search
-        const results = await qdrant.hybridSearch(
-          collection,
-          embedding,
-          sparseVector,
-          limit || 5,
-          filter,
-        );
+      // Perform hybrid search
+      const results = await qdrant.hybridSearch(
+        collection,
+        embedding,
+        sparseVector,
+        limit || 5,
+        filter
+      );
 
-        return {
-          content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-        };
-      },
-    ),
+      return {
+        content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+      };
+    })
   );
 }

package/tests/code/chunker/tree-sitter-chunker.test.ts

@@ -126,10 +126,8 @@ def calculate_average(numbers):
       if (chunks.length > 0) {
         expect(
           chunks.some(
-            (c) =>
-              c.metadata.name === "calculate_sum" ||
-              c.metadata.name === "calculate_product",
-          ),
+            (c) => c.metadata.name === "calculate_sum" || c.metadata.name === "calculate_product"
+          )
         ).toBe(true);
       }
     });
@@ -184,11 +182,7 @@ function veryLargeFunction() {
 }
       `;
 
-      const chunks = await chunker.chunk(
-        largeFunction,
-        "test.js",
-        "javascript",
-      );
+      const chunks = await chunker.chunk(largeFunction, "test.js", "javascript");
       expect(chunks.length).toBeGreaterThan(0);
     });
 
@@ -216,13 +210,8 @@ function myFunction() {
     });
 
     it("should include file path and language", async () => {
-      const code =
-        "function test() {\n  console.log('Test function');\n  return true;\n}";
-      const chunks = await chunker.chunk(
-        code,
-        "/path/to/file.ts",
-        "typescript",
-      );
+      const code = "function test() {\n  console.log('Test function');\n  return true;\n}";
+      const chunks = await chunker.chunk(code, "/path/to/file.ts", "typescript");
 
       expect(chunks[0].metadata.filePath).toBe("/path/to/file.ts");
       expect(chunks[0].metadata.language).toBe("typescript");
@@ -337,9 +326,7 @@ trait Printable {
       expect(chunks.length).toBeGreaterThanOrEqual(0);
       // Should classify as interface type due to trait pattern
       if (chunks.length > 0) {
-        expect(chunks.some((c) => c.metadata.chunkType === "interface")).toBe(
-          true,
-        );
+        expect(chunks.some((c) => c.metadata.chunkType === "interface")).toBe(true);
       }
     });