@mhalder/qdrant-mcp-server 2.1.0 → 2.1.2

package/src/prompts/register.ts

@@ -0,0 +1,71 @@
+/**
+ * Prompt registration module for McpServer
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { renderTemplate, validateArguments } from "./template.js";
+import type { PromptArgument, PromptsConfig } from "./types.js";
+
+/**
+ * Build a Zod schema object for prompt arguments
+ */
+function buildArgsSchema(args: PromptArgument[]): Record<string, z.ZodTypeAny> {
+  const schema: Record<string, z.ZodTypeAny> = {};
+
+  for (const arg of args) {
+    const fieldSchema = z.string().describe(arg.description);
+    schema[arg.name] = arg.required ? fieldSchema : fieldSchema.optional();
+  }
+
+  return schema;
+}
+
+/**
+ * Register all prompts from configuration on the server
+ */
+export function registerAllPrompts(
+  server: McpServer,
+  config: PromptsConfig | null,
+): void {
+  if (!config) {
+    return; // No prompts = no prompts capability
+  }
+
+  for (const prompt of config.prompts) {
+    const argsSchema = buildArgsSchema(prompt.arguments);
+
+    server.registerPrompt(
+      prompt.name,
+      {
+        title: prompt.name,
+        description: prompt.description,
+        argsSchema,
+      },
+      (args) => {
+        // Validate arguments
+        const argsRecord = (args || {}) as Record<string, string>;
+        validateArguments(argsRecord, prompt.arguments);
+
+        // Render template
+        const rendered = renderTemplate(
+          prompt.template,
+          argsRecord,
+          prompt.arguments,
+        );
+
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: rendered.text,
+              },
+            },
+          ],
+        };
+      },
+    );
+  }
+}

package/src/resources/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Resource registration module
+ */
+
+import {
+  McpServer,
+  ResourceTemplate,
+} from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { QdrantManager } from "../qdrant/client.js";
+
+/**
+ * Register all MCP resources on the server
+ */
+export function registerAllResources(
+  server: McpServer,
+  qdrant: QdrantManager,
+): void {
+  // Static resource: list all collections
+  server.registerResource(
+    "collections",
+    "qdrant://collections",
+    {
+      title: "All Collections",
+      description: "List of all vector collections in Qdrant",
+      mimeType: "application/json",
+    },
+    async (uri) => {
+      const collections = await qdrant.listCollections();
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(collections, null, 2),
+          },
+        ],
+      };
+    },
+  );
+
+  // Dynamic resource: individual collection info
+  server.registerResource(
+    "collection-info",
+    new ResourceTemplate("qdrant://collection/{name}", {
+      list: async () => {
+        const collections = await qdrant.listCollections();
+        return {
+          resources: collections.map((name) => ({
+            uri: `qdrant://collection/${name}`,
+            name: `Collection: ${name}`,
+            description: `Details and statistics for collection "${name}"`,
+            mimeType: "application/json",
+          })),
+        };
+      },
+    }),
+    {
+      title: "Collection Details",
+      description: "Detailed information about a specific collection",
+      mimeType: "application/json",
+    },
+    async (uri, params) => {
+      const name = params.name;
+      if (typeof name !== "string" || !name) {
+        throw new Error("Invalid collection name parameter");
+      }
+      const info = await qdrant.getCollectionInfo(name);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(info, null, 2),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/tools/code.ts

@@ -0,0 +1,195 @@
+/**
+ * Code indexing tools registration
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CodeIndexer } from "../code/indexer.js";
+import * as schemas from "./schemas.js";
+
+export interface CodeToolDependencies {
+  codeIndexer: CodeIndexer;
+}
+
+export function registerCodeTools(
+  server: McpServer,
+  deps: CodeToolDependencies,
+): void {
+  const { codeIndexer } = deps;
+
+  // index_codebase
+  server.registerTool(
+    "index_codebase",
+    {
+      title: "Index Codebase",
+      description:
+        "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")}`;
+      }
+
+      return {
+        content: [{ type: "text", text: statusMessage }],
+        isError: stats.status === "failed",
+      };
+    },
+  );
+
+  // search_code
+  server.registerTool(
+    "search_code",
+    {
+      title: "Search Code",
+      description:
+        "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,
+      });
+
+      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");
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${results.length} result(s):\n${formattedResults}`,
+          },
+        ],
+      };
+    },
+  );
+
+  // reindex_changes
+  server.registerTool(
+    "reindex_changes",
+    {
+      title: "Reindex Changes",
+      description:
+        "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 }) => {
+      const stats = await codeIndexer.reindexChanges(path, (progress) => {
+        console.error(
+          `[${progress.phase}] ${progress.percentage}% - ${progress.message}`,
+        );
+      });
+
+      let message = `Incremental re-index complete:\n`;
+      message += `- Files added: ${stats.filesAdded}\n`;
+      message += `- Files modified: ${stats.filesModified}\n`;
+      message += `- Files deleted: ${stats.filesDeleted}\n`;
+      message += `- Chunks added: ${stats.chunksAdded}\n`;
+      message += `- Duration: ${(stats.durationMs / 1000).toFixed(1)}s`;
+
+      if (
+        stats.filesAdded === 0 &&
+        stats.filesModified === 0 &&
+        stats.filesDeleted === 0
+      ) {
+        message = `No changes detected. Codebase is up to date.`;
+      }
+
+      return {
+        content: [{ type: "text", text: message }],
+      };
+    },
+  );
+
+  // get_index_status
+  server.registerTool(
+    "get_index_status",
+    {
+      title: "Get Index Status",
+      description: "Get indexing status and statistics for a codebase.",
+      inputSchema: schemas.GetIndexStatusSchema,
+    },
+    async ({ path }) => {
+      const status = await codeIndexer.getIndexStatus(path);
+
+      if (status.status === "not_indexed") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Codebase at "${path}" is not indexed. Use index_codebase to index it first.`,
+            },
+          ],
+        };
+      }
+
+      if (status.status === "indexing") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Codebase at "${path}" is currently being indexed. ${status.chunksCount || 0} chunks processed so far.`,
+            },
+          ],
+        };
+      }
+
+      return {
+        content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
+      };
+    },
+  );
+
+  // clear_index
+  server.registerTool(
+    "clear_index",
+    {
+      title: "Clear Index",
+      description:
+        "Delete all indexed data for a codebase. This is irreversible and will remove the entire collection.",
+      inputSchema: schemas.ClearIndexSchema,
+    },
+    async ({ path }) => {
+      await codeIndexer.clearIndex(path);
+      return {
+        content: [
+          { type: "text", text: `Index cleared for codebase at "${path}".` },
+        ],
+      };
+    },
+  );
+}

package/src/tools/collection.ts

@@ -0,0 +1,100 @@
+/**
+ * Collection management tools registration
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { EmbeddingProvider } from "../embeddings/base.js";
+import type { QdrantManager } from "../qdrant/client.js";
+import * as schemas from "./schemas.js";
+
+export interface CollectionToolDependencies {
+  qdrant: QdrantManager;
+  embeddings: EmbeddingProvider;
+}
+
+export function registerCollectionTools(
+  server: McpServer,
+  deps: CollectionToolDependencies,
+): void {
+  const { qdrant, embeddings } = deps;
+
+  // create_collection
+  server.registerTool(
+    "create_collection",
+    {
+      title: "Create Collection",
+      description:
+        "Create a new vector collection in Qdrant. The collection will be configured with the embedding provider's dimensions automatically. Set enableHybrid to true to enable hybrid search combining semantic and keyword search.",
+      inputSchema: schemas.CreateCollectionSchema,
+    },
+    async ({ name, distance, enableHybrid }) => {
+      const vectorSize = embeddings.getDimensions();
+      await qdrant.createCollection(
+        name,
+        vectorSize,
+        distance,
+        enableHybrid || false,
+      );
+
+      let message = `Collection "${name}" created successfully with ${vectorSize} dimensions and ${distance || "Cosine"} distance metric.`;
+      if (enableHybrid) {
+        message += " Hybrid search is enabled for this collection.";
+      }
+
+      return {
+        content: [{ type: "text", text: message }],
+      };
+    },
+  );
+
+  // list_collections
+  server.registerTool(
+    "list_collections",
+    {
+      title: "List Collections",
+      description: "List all available collections in Qdrant.",
+      inputSchema: {},
+    },
+    async () => {
+      const collections = await qdrant.listCollections();
+      return {
+        content: [{ type: "text", text: JSON.stringify(collections, null, 2) }],
+      };
+    },
+  );
+
+  // get_collection_info
+  server.registerTool(
+    "get_collection_info",
+    {
+      title: "Get Collection Info",
+      description:
+        "Get detailed information about a collection including vector size, point count, and distance metric.",
+      inputSchema: schemas.GetCollectionInfoSchema,
+    },
+    async ({ name }) => {
+      const info = await qdrant.getCollectionInfo(name);
+      return {
+        content: [{ type: "text", text: JSON.stringify(info, null, 2) }],
+      };
+    },
+  );
+
+  // delete_collection
+  server.registerTool(
+    "delete_collection",
+    {
+      title: "Delete Collection",
+      description: "Delete a collection and all its documents.",
+      inputSchema: schemas.DeleteCollectionSchema,
+    },
+    async ({ name }) => {
+      await qdrant.deleteCollection(name);
+      return {
+        content: [
+          { type: "text", text: `Collection "${name}" deleted successfully.` },
+        ],
+      };
+    },
+  );
+}

package/src/tools/document.ts

@@ -0,0 +1,113 @@
+/**
+ * Document operation tools registration
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { EmbeddingProvider } from "../embeddings/base.js";
+import { BM25SparseVectorGenerator } from "../embeddings/sparse.js";
+import type { QdrantManager } from "../qdrant/client.js";
+import * as schemas from "./schemas.js";
+
+export interface DocumentToolDependencies {
+  qdrant: QdrantManager;
+  embeddings: EmbeddingProvider;
+}
+
+export function registerDocumentTools(
+  server: McpServer,
+  deps: DocumentToolDependencies,
+): void {
+  const { qdrant, embeddings } = deps;
+
+  // add_documents
+  server.registerTool(
+    "add_documents",
+    {
+      title: "Add Documents",
+      description:
+        "Add documents to a collection. Documents will be automatically embedded using the configured embedding provider.",
+      inputSchema: schemas.AddDocumentsSchema,
+    },
+    async ({ collection, documents }) => {
+      // Check if collection exists and get info
+      const exists = await qdrant.collectionExists(collection);
+      if (!exists) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: Collection "${collection}" does not exist. Create it first using create_collection.`,
+            },
+          ],
+          isError: true,
+        };
+      }
+
+      const collectionInfo = await qdrant.getCollectionInfo(collection);
+
+      // Generate embeddings for all documents
+      const texts = documents.map((doc) => doc.text);
+      const embeddingResults = await embeddings.embedBatch(texts);
+
+      // If hybrid search is enabled, generate sparse vectors and use appropriate method
+      if (collectionInfo.hybridEnabled) {
+        const sparseGenerator = new BM25SparseVectorGenerator();
+
+        // Prepare points with both dense and sparse vectors
+        const points = documents.map((doc, index) => ({
+          id: doc.id,
+          vector: embeddingResults[index].embedding,
+          sparseVector: sparseGenerator.generate(doc.text),
+          payload: {
+            text: doc.text,
+            ...doc.metadata,
+          },
+        }));
+
+        await qdrant.addPointsWithSparse(collection, points);
+      } else {
+        // Standard dense-only vectors
+        const points = documents.map((doc, index) => ({
+          id: doc.id,
+          vector: embeddingResults[index].embedding,
+          payload: {
+            text: doc.text,
+            ...doc.metadata,
+          },
+        }));
+
+        await qdrant.addPoints(collection, points);
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Successfully added ${documents.length} document(s) to collection "${collection}".`,
+          },
+        ],
+      };
+    },
+  );
+
+  // delete_documents
+  server.registerTool(
+    "delete_documents",
+    {
+      title: "Delete Documents",
+      description: "Delete specific documents from a collection by their IDs.",
+      inputSchema: schemas.DeleteDocumentsSchema,
+    },
+    async ({ collection, ids }) => {
+      await qdrant.deletePoints(collection, ids);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Successfully deleted ${ids.length} document(s) from collection "${collection}".`,
+          },
+        ],
+      };
+    },
+  );
+}

package/src/tools/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Tool registration orchestrator
+ */
+
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CodeIndexer } from "../code/indexer.js";
+import type { EmbeddingProvider } from "../embeddings/base.js";
+import type { QdrantManager } from "../qdrant/client.js";
+import { registerCodeTools } from "./code.js";
+import { registerCollectionTools } from "./collection.js";
+import { registerDocumentTools } from "./document.js";
+import { registerSearchTools } from "./search.js";
+
+export interface ToolDependencies {
+  qdrant: QdrantManager;
+  embeddings: EmbeddingProvider;
+  codeIndexer: CodeIndexer;
+}
+
+/**
+ * Register all MCP tools on the server
+ */
+export function registerAllTools(
+  server: McpServer,
+  deps: ToolDependencies,
+): void {
+  registerCollectionTools(server, {
+    qdrant: deps.qdrant,
+    embeddings: deps.embeddings,
+  });
+
+  registerDocumentTools(server, {
+    qdrant: deps.qdrant,
+    embeddings: deps.embeddings,
+  });
+
+  registerSearchTools(server, {
+    qdrant: deps.qdrant,
+    embeddings: deps.embeddings,
+  });
+
+  registerCodeTools(server, {
+    codeIndexer: deps.codeIndexer,
+  });
+}
+
+// Re-export schemas for external use
+export * from "./schemas.js";