@mhalder/qdrant-mcp-server 1.2.0 → 1.3.1

package/src/index.ts

@@ -5,12 +5,15 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import {
   CallToolRequestSchema,
   ListResourcesRequestSchema,
   ListToolsRequestSchema,
   ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
+import Bottleneck from "bottleneck";
+import express from "express";
 import { z } from "zod";
 import { EmbeddingProviderFactory } from "./embeddings/factory.js";
 import { BM25SparseVectorGenerator } from "./embeddings/sparse.js";
@@ -23,6 +26,18 @@ const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8")
 // Validate environment variables
 const QDRANT_URL = process.env.QDRANT_URL || "http://localhost:6333";
 const EMBEDDING_PROVIDER = (process.env.EMBEDDING_PROVIDER || "ollama").toLowerCase();
+const TRANSPORT_MODE = (process.env.TRANSPORT_MODE || "stdio").toLowerCase();
+const HTTP_PORT = parseInt(process.env.HTTP_PORT || "3000", 10);
+
+// 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.`
+    );
+    process.exit(1);
+  }
+}
 
 // Check for required API keys based on provider
 if (EMBEDDING_PROVIDER !== "ollama") {
@@ -124,594 +139,820 @@ async function checkOllamaAvailability() {
 const qdrant = new QdrantManager(QDRANT_URL);
 const embeddings = EmbeddingProviderFactory.createFromEnv();
 
-// Create MCP server
-const server = new Server(
-  {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  {
-    capabilities: {
-      tools: {},
-      resources: {},
+// Function to create a new MCP server instance
+// This is needed for HTTP transport in stateless mode where each request gets its own server
+function createServer() {
+  return new Server(
+    {
+      name: pkg.name,
+      version: pkg.version,
     },
-  }
-);
-
-// Tool schemas
-const CreateCollectionSchema = z.object({
-  name: z.string().describe("Name of the collection"),
-  distance: z
-    .enum(["Cosine", "Euclid", "Dot"])
-    .optional()
-    .describe("Distance metric (default: Cosine)"),
-  enableHybrid: z
-    .boolean()
-    .optional()
-    .describe("Enable hybrid search with sparse vectors (default: false)"),
-});
-
-const AddDocumentsSchema = z.object({
-  collection: z.string().describe("Name of the collection"),
-  documents: z
-    .array(
-      z.object({
-        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.any())
-          .optional()
-          .describe("Optional metadata to store with the document"),
-      })
-    )
-    .describe("Array of documents to add"),
-});
-
-const SemanticSearchSchema = z.object({
-  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.any()).optional().describe("Optional metadata filter"),
-});
-
-const DeleteCollectionSchema = z.object({
-  name: z.string().describe("Name of the collection to delete"),
-});
-
-const GetCollectionInfoSchema = z.object({
-  name: z.string().describe("Name of the collection"),
-});
-
-const DeleteDocumentsSchema = z.object({
-  collection: z.string().describe("Name of the collection"),
-  ids: z.array(z.union([z.string(), z.number()])).describe("Array of document IDs to delete"),
-});
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+      },
+    }
+  );
+}
 
-const HybridSearchSchema = z.object({
-  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.any()).optional().describe("Optional metadata filter"),
-});
+// Create a shared MCP server for stdio mode
+const server = createServer();
 
-// List available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: "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: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Name of the collection",
-            },
-            distance: {
-              type: "string",
-              enum: ["Cosine", "Euclid", "Dot"],
-              description: "Distance metric (default: Cosine)",
-            },
-            enableHybrid: {
-              type: "boolean",
-              description: "Enable hybrid search with sparse vectors (default: false)",
+// Function to register all handlers on a server instance
+function registerHandlers(server: Server) {
+  // List available tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "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: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Name of the collection",
+              },
+              distance: {
+                type: "string",
+                enum: ["Cosine", "Euclid", "Dot"],
+                description: "Distance metric (default: Cosine)",
+              },
+              enableHybrid: {
+                type: "boolean",
+                description: "Enable hybrid search with sparse vectors (default: false)",
+              },
             },
+            required: ["name"],
           },
-          required: ["name"],
         },
-      },
-      {
-        name: "add_documents",
-        description:
-          "Add documents to a collection. Documents will be automatically embedded using the configured embedding provider.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection",
-            },
-            documents: {
-              type: "array",
-              description: "Array of documents to add",
-              items: {
-                type: "object",
-                properties: {
-                  id: {
-                    type: ["string", "number"],
-                    description: "Unique identifier for the document",
-                  },
-                  text: {
-                    type: "string",
-                    description: "Text content to embed and store",
-                  },
-                  metadata: {
-                    type: "object",
-                    description: "Optional metadata to store with the document",
+        {
+          name: "add_documents",
+          description:
+            "Add documents to a collection. Documents will be automatically embedded using the configured embedding provider.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              collection: {
+                type: "string",
+                description: "Name of the collection",
+              },
+              documents: {
+                type: "array",
+                description: "Array of documents to add",
+                items: {
+                  type: "object",
+                  properties: {
+                    id: {
+                      type: ["string", "number"],
+                      description: "Unique identifier for the document",
+                    },
+                    text: {
+                      type: "string",
+                      description: "Text content to embed and store",
+                    },
+                    metadata: {
+                      type: "object",
+                      description: "Optional metadata to store with the document",
+                    },
                   },
+                  required: ["id", "text"],
                 },
-                required: ["id", "text"],
               },
             },
+            required: ["collection", "documents"],
           },
-          required: ["collection", "documents"],
         },
-      },
-      {
-        name: "semantic_search",
-        description:
-          "Search for documents using natural language queries. Returns the most semantically similar documents.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection to search",
-            },
-            query: {
-              type: "string",
-              description: "Search query text",
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of results (default: 5)",
-            },
-            filter: {
-              type: "object",
-              description: "Optional metadata filter",
+        {
+          name: "semantic_search",
+          description:
+            "Search for documents using natural language queries. Returns the most semantically similar documents.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              collection: {
+                type: "string",
+                description: "Name of the collection to search",
+              },
+              query: {
+                type: "string",
+                description: "Search query text",
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of results (default: 5)",
+              },
+              filter: {
+                type: "object",
+                description: "Optional metadata filter",
+              },
             },
+            required: ["collection", "query"],
           },
-          required: ["collection", "query"],
         },
-      },
-      {
-        name: "list_collections",
-        description: "List all available collections in Qdrant.",
-        inputSchema: {
-          type: "object",
-          properties: {},
+        {
+          name: "list_collections",
+          description: "List all available collections in Qdrant.",
+          inputSchema: {
+            type: "object",
+            properties: {},
+          },
         },
-      },
-      {
-        name: "delete_collection",
-        description: "Delete a collection and all its documents.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Name of the collection to delete",
+        {
+          name: "delete_collection",
+          description: "Delete a collection and all its documents.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Name of the collection to delete",
+              },
             },
+            required: ["name"],
           },
-          required: ["name"],
         },
-      },
-      {
-        name: "get_collection_info",
-        description:
-          "Get detailed information about a collection including vector size, point count, and distance metric.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Name of the collection",
+        {
+          name: "get_collection_info",
+          description:
+            "Get detailed information about a collection including vector size, point count, and distance metric.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Name of the collection",
+              },
             },
+            required: ["name"],
           },
-          required: ["name"],
         },
-      },
-      {
-        name: "delete_documents",
-        description: "Delete specific documents from a collection by their IDs.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection",
-            },
-            ids: {
-              type: "array",
-              description: "Array of document IDs to delete",
-              items: {
-                type: ["string", "number"],
+        {
+          name: "delete_documents",
+          description: "Delete specific documents from a collection by their IDs.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              collection: {
+                type: "string",
+                description: "Name of the collection",
+              },
+              ids: {
+                type: "array",
+                description: "Array of document IDs to delete",
+                items: {
+                  type: ["string", "number"],
+                },
               },
             },
+            required: ["collection", "ids"],
           },
-          required: ["collection", "ids"],
         },
-      },
-      {
-        name: "hybrid_search",
-        description:
-          "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: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection to search",
-            },
-            query: {
-              type: "string",
-              description: "Search query text",
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of results (default: 5)",
-            },
-            filter: {
-              type: "object",
-              description: "Optional metadata filter",
+        {
+          name: "hybrid_search",
+          description:
+            "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: {
+            type: "object",
+            properties: {
+              collection: {
+                type: "string",
+                description: "Name of the collection to search",
+              },
+              query: {
+                type: "string",
+                description: "Search query text",
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of results (default: 5)",
+              },
+              filter: {
+                type: "object",
+                description: "Optional metadata filter",
+              },
             },
+            required: ["collection", "query"],
           },
-          required: ["collection", "query"],
         },
-      },
-    ],
-  };
-});
+      ],
+    };
+  });
 
-// Handle tool calls
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
+  // Handle tool calls
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
 
-  try {
-    switch (name) {
-      case "create_collection": {
-        const { name, distance, enableHybrid } = CreateCollectionSchema.parse(args);
-        const vectorSize = embeddings.getDimensions();
-        await qdrant.createCollection(name, vectorSize, distance, enableHybrid || false);
+    try {
+      switch (name) {
+        case "create_collection": {
+          const { name, distance, enableHybrid } = CreateCollectionSchema.parse(args);
+          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.";
+          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,
+              },
+            ],
+          };
         }
 
-        return {
-          content: [
-            {
-              type: "text",
-              text: message,
-            },
-          ],
-        };
-      }
+        case "add_documents": {
+          const { collection, documents } = AddDocumentsSchema.parse(args);
+
+          // 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,
+              },
+            }));
 
-      case "add_documents": {
-        const { collection, documents } = AddDocumentsSchema.parse(args);
+            await qdrant.addPoints(collection, points);
+          }
 
-        // 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.`,
+                text: `Successfully added ${documents.length} document(s) to collection "${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();
+        case "semantic_search": {
+          const { collection, query, limit, filter } = SemanticSearchSchema.parse(args);
+
+          // 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,
+            };
+          }
 
-          // 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,
-            },
-          }));
+          // Generate embedding for query
+          const { embedding } = await embeddings.embed(query);
 
-          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,
-            },
-          }));
+          // Search
+          const results = await qdrant.search(collection, embedding, limit || 5, filter);
 
-          await qdrant.addPoints(collection, points);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(results, null, 2),
+              },
+            ],
+          };
         }
 
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Successfully added ${documents.length} document(s) to collection "${collection}".`,
-            },
-          ],
-        };
-      }
-
-      case "semantic_search": {
-        const { collection, query, limit, filter } = SemanticSearchSchema.parse(args);
-
-        // Check if collection exists
-        const exists = await qdrant.collectionExists(collection);
-        if (!exists) {
+        case "list_collections": {
+          const collections = await qdrant.listCollections();
           return {
             content: [
               {
                 type: "text",
-                text: `Error: Collection "${collection}" does not exist.`,
+                text: JSON.stringify(collections, null, 2),
               },
             ],
-            isError: true,
           };
         }
 
-        // Generate embedding for query
-        const { embedding } = await embeddings.embed(query);
-
-        // Search
-        const results = await qdrant.search(collection, embedding, limit || 5, filter);
+        case "delete_collection": {
+          const { name } = DeleteCollectionSchema.parse(args);
+          await qdrant.deleteCollection(name);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Collection "${name}" deleted successfully.`,
+              },
+            ],
+          };
+        }
 
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(results, null, 2),
-            },
-          ],
-        };
-      }
+        case "get_collection_info": {
+          const { name } = GetCollectionInfoSchema.parse(args);
+          const info = await qdrant.getCollectionInfo(name);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(info, null, 2),
+              },
+            ],
+          };
+        }
 
-      case "list_collections": {
-        const collections = await qdrant.listCollections();
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(collections, null, 2),
-            },
-          ],
-        };
-      }
+        case "delete_documents": {
+          const { collection, ids } = DeleteDocumentsSchema.parse(args);
+          await qdrant.deletePoints(collection, ids);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Successfully deleted ${ids.length} document(s) from collection "${collection}".`,
+              },
+            ],
+          };
+        }
 
-      case "delete_collection": {
-        const { name } = DeleteCollectionSchema.parse(args);
-        await qdrant.deleteCollection(name);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Collection "${name}" deleted successfully.`,
-            },
-          ],
-        };
-      }
+        case "hybrid_search": {
+          const { collection, query, limit, filter } = HybridSearchSchema.parse(args);
+
+          // 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,
+            };
+          }
 
-      case "get_collection_info": {
-        const { name } = GetCollectionInfoSchema.parse(args);
-        const info = await qdrant.getCollectionInfo(name);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(info, null, 2),
-            },
-          ],
-        };
-      }
+          // Generate dense embedding for query
+          const { embedding } = await embeddings.embed(query);
 
-      case "delete_documents": {
-        const { collection, ids } = DeleteDocumentsSchema.parse(args);
-        await qdrant.deletePoints(collection, ids);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Successfully deleted ${ids.length} document(s) from collection "${collection}".`,
-            },
-          ],
-        };
-      }
+          // Generate sparse vector for query
+          const sparseGenerator = new BM25SparseVectorGenerator();
+          const sparseVector = sparseGenerator.generate(query);
 
-      case "hybrid_search": {
-        const { collection, query, limit, filter } = HybridSearchSchema.parse(args);
+          // Perform hybrid search
+          const results = await qdrant.hybridSearch(
+            collection,
+            embedding,
+            sparseVector,
+            limit || 5,
+            filter
+          );
 
-        // Check if collection exists
-        const exists = await qdrant.collectionExists(collection);
-        if (!exists) {
           return {
             content: [
               {
                 type: "text",
-                text: `Error: Collection "${collection}" does not exist.`,
+                text: JSON.stringify(results, null, 2),
               },
             ],
-            isError: true,
           };
         }
 
-        // Check if collection has hybrid search enabled
-        const collectionInfo = await qdrant.getCollectionInfo(collection);
-        if (!collectionInfo.hybridEnabled) {
+        default:
           return {
             content: [
               {
                 type: "text",
-                text: `Error: Collection "${collection}" does not have hybrid search enabled. Create a new collection with enableHybrid set to true.`,
+                text: `Unknown tool: ${name}`,
               },
             ],
             isError: true,
           };
-        }
-
-        // 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);
-
-        // Perform hybrid search
-        const results = await qdrant.hybridSearch(
-          collection,
-          embedding,
-          sparseVector,
-          limit || 5,
-          filter
-        );
-
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(results, null, 2),
-            },
-          ],
-        };
       }
-
-      default:
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Unknown tool: ${name}`,
-            },
-          ],
-          isError: true,
-        };
+    } catch (error: any) {
+      // Enhanced error details for debugging
+      const errorDetails = error instanceof Error ? error.message : JSON.stringify(error, null, 2);
+
+      console.error("Tool execution error:", {
+        tool: name,
+        error: errorDetails,
+        stack: error?.stack,
+        data: error?.data,
+      });
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${errorDetails}`,
+          },
+        ],
+        isError: true,
+      };
     }
-  } catch (error: any) {
-    // Enhanced error details for debugging
-    const errorDetails = error instanceof Error ? error.message : JSON.stringify(error, null, 2);
-
-    console.error("Tool execution error:", {
-      tool: name,
-      error: errorDetails,
-      stack: error?.stack,
-      data: error?.data,
-    });
+  });
 
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${errorDetails}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-});
-
-// List available resources
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  const collections = await qdrant.listCollections();
-
-  return {
-    resources: [
-      {
-        uri: "qdrant://collections",
-        name: "All Collections",
-        description: "List of all vector collections in Qdrant",
-        mimeType: "application/json",
-      },
-      ...collections.map((name) => ({
-        uri: `qdrant://collection/${name}`,
-        name: `Collection: ${name}`,
-        description: `Details and statistics for collection "${name}"`,
-        mimeType: "application/json",
-      })),
-    ],
-  };
-});
-
-// Read resource content
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  const { uri } = request.params;
-
-  if (uri === "qdrant://collections") {
+  // List available resources
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
     const collections = await qdrant.listCollections();
+
     return {
-      contents: [
+      resources: [
         {
-          uri,
+          uri: "qdrant://collections",
+          name: "All Collections",
+          description: "List of all vector collections in Qdrant",
           mimeType: "application/json",
-          text: JSON.stringify(collections, null, 2),
         },
+        ...collections.map((name) => ({
+          uri: `qdrant://collection/${name}`,
+          name: `Collection: ${name}`,
+          description: `Details and statistics for collection "${name}"`,
+          mimeType: "application/json",
+        })),
       ],
     };
-  }
+  });
+
+  // Read resource content
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+
+    if (uri === "qdrant://collections") {
+      const collections = await qdrant.listCollections();
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(collections, null, 2),
+          },
+        ],
+      };
+    }
+
+    const collectionMatch = uri.match(/^qdrant:\/\/collection\/(.+)$/);
+    if (collectionMatch) {
+      const name = collectionMatch[1];
+      const info = await qdrant.getCollectionInfo(name);
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(info, null, 2),
+          },
+        ],
+      };
+    }
 
-  const collectionMatch = uri.match(/^qdrant:\/\/collection\/(.+)$/);
-  if (collectionMatch) {
-    const name = collectionMatch[1];
-    const info = await qdrant.getCollectionInfo(name);
     return {
       contents: [
         {
           uri,
-          mimeType: "application/json",
-          text: JSON.stringify(info, null, 2),
+          mimeType: "text/plain",
+          text: `Unknown resource: ${uri}`,
         },
       ],
     };
-  }
+  });
+}
 
-  return {
-    contents: [
-      {
-        uri,
-        mimeType: "text/plain",
-        text: `Unknown resource: ${uri}`,
-      },
-    ],
-  };
+// Register handlers on the shared server for stdio mode
+registerHandlers(server);
+
+// Tool schemas
+const CreateCollectionSchema = z.object({
+  name: z.string().describe("Name of the collection"),
+  distance: z
+    .enum(["Cosine", "Euclid", "Dot"])
+    .optional()
+    .describe("Distance metric (default: Cosine)"),
+  enableHybrid: z
+    .boolean()
+    .optional()
+    .describe("Enable hybrid search with sparse vectors (default: false)"),
 });
 
-// Start server
-async function main() {
+const AddDocumentsSchema = z.object({
+  collection: z.string().describe("Name of the collection"),
+  documents: z
+    .array(
+      z.object({
+        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.any())
+          .optional()
+          .describe("Optional metadata to store with the document"),
+      })
+    )
+    .describe("Array of documents to add"),
+});
+
+const SemanticSearchSchema = z.object({
+  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.any()).optional().describe("Optional metadata filter"),
+});
+
+const DeleteCollectionSchema = z.object({
+  name: z.string().describe("Name of the collection to delete"),
+});
+
+const GetCollectionInfoSchema = z.object({
+  name: z.string().describe("Name of the collection"),
+});
+
+const DeleteDocumentsSchema = z.object({
+  collection: z.string().describe("Name of the collection"),
+  ids: z.array(z.union([z.string(), z.number()])).describe("Array of document IDs to delete"),
+});
+
+const HybridSearchSchema = z.object({
+  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.any()).optional().describe("Optional metadata filter"),
+});
+
+// Start server with stdio transport
+async function startStdioServer() {
   await checkOllamaAvailability();
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error("Qdrant MCP server running on stdio");
 }
 
+// Constants for HTTP server configuration
+const RATE_LIMIT_MAX_REQUESTS = 100; // Max requests per window
+const RATE_LIMIT_WINDOW_MS = 15 * 60 * 1000; // 15 minutes
+const RATE_LIMIT_MAX_CONCURRENT = 10; // Max concurrent requests per IP
+const RATE_LIMITER_CLEANUP_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
+const REQUEST_TIMEOUT_MS = 30 * 1000; // 30 seconds per request
+const SHUTDOWN_GRACE_PERIOD_MS = 10 * 1000; // 10 seconds
+
+// Start server with HTTP transport
+async function startHttpServer() {
+  await checkOllamaAvailability();
+
+  const app = express();
+  app.use(express.json({ limit: "10mb" }));
+
+  // Configure Express to trust proxy for correct IP detection
+  app.set("trust proxy", true);
+
+  // Rate limiter group: max 100 requests per 15 minutes per IP, max 10 concurrent per IP
+  const rateLimiterGroup = new Bottleneck.Group({
+    reservoir: RATE_LIMIT_MAX_REQUESTS,
+    reservoirRefreshAmount: RATE_LIMIT_MAX_REQUESTS,
+    reservoirRefreshInterval: RATE_LIMIT_WINDOW_MS,
+    maxConcurrent: RATE_LIMIT_MAX_CONCURRENT,
+  });
+
+  // Helper function to send JSON-RPC error responses
+  const sendErrorResponse = (
+    res: express.Response,
+    code: number,
+    message: string,
+    httpStatus: number = 500
+  ) => {
+    if (!res.headersSent) {
+      res.status(httpStatus).json({
+        jsonrpc: "2.0",
+        error: { code, message },
+        id: null,
+      });
+    }
+  };
+
+  // Periodic cleanup of inactive rate limiters to prevent memory leaks
+  // Track last access time for each IP
+  const ipLastAccess = new Map<string, number>();
+
+  const cleanupIntervalId = setInterval(() => {
+    const now = Date.now();
+    const keysToDelete: string[] = [];
+
+    ipLastAccess.forEach((lastAccess, ip) => {
+      if (now - lastAccess > RATE_LIMITER_CLEANUP_INTERVAL_MS) {
+        keysToDelete.push(ip);
+      }
+    });
+
+    keysToDelete.forEach((ip) => {
+      rateLimiterGroup.deleteKey(ip);
+      ipLastAccess.delete(ip);
+    });
+
+    if (keysToDelete.length > 0) {
+      console.error(`Cleaned up ${keysToDelete.length} inactive rate limiters`);
+    }
+  }, RATE_LIMITER_CLEANUP_INTERVAL_MS);
+
+  // Rate limiting middleware
+  const rateLimitMiddleware = async (
+    req: express.Request,
+    res: express.Response,
+    next: express.NextFunction
+  ) => {
+    const clientIp = req.ip || req.socket.remoteAddress || "unknown";
+
+    try {
+      // Update last access time for this IP
+      ipLastAccess.set(clientIp, Date.now());
+
+      // Get or create a limiter for this specific IP
+      const limiter = rateLimiterGroup.key(clientIp);
+      await limiter.schedule(() => Promise.resolve());
+      next();
+    } 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);
+      } else {
+        console.error("Unexpected rate limiting error:", error);
+      }
+      sendErrorResponse(res, -32000, "Too many requests", 429);
+    }
+  };
+
+  // Health check endpoint
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      mode: TRANSPORT_MODE,
+      version: pkg.version,
+      embedding_provider: EMBEDDING_PROVIDER,
+    });
+  });
+
+  app.post("/mcp", rateLimitMiddleware, async (req, res) => {
+    // Create a new server for each request
+    const requestServer = createServer();
+    registerHandlers(requestServer);
+
+    // Create transport with enableJsonResponse
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: undefined,
+      enableJsonResponse: true,
+    });
+
+    // Track cleanup state to prevent double cleanup
+    let cleanedUp = false;
+    const cleanup = async () => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      await transport.close().catch(() => {});
+      await requestServer.close().catch(() => {});
+    };
+
+    // Set a timeout for the request to prevent hanging
+    const timeoutId = setTimeout(() => {
+      sendErrorResponse(res, -32000, "Request timeout", 504);
+      cleanup().catch((err) => {
+        console.error("Error during timeout cleanup:", err);
+      });
+    }, REQUEST_TIMEOUT_MS);
+
+    try {
+      // Connect server to transport
+      await requestServer.connect(transport);
+
+      // Handle the request - this triggers message processing
+      // The response will be sent asynchronously when the server calls transport.send()
+      await transport.handleRequest(req, res, req.body);
+
+      // Clean up AFTER the response finishes
+      // Listen to multiple events to ensure cleanup happens in all scenarios
+      const cleanupHandler = () => {
+        clearTimeout(timeoutId);
+        cleanup().catch((err) => {
+          console.error("Error during response cleanup:", err);
+        });
+      };
+
+      res.on("finish", cleanupHandler);
+      res.on("close", cleanupHandler);
+      res.on("error", (err) => {
+        console.error("Response stream error:", err);
+        cleanupHandler();
+      });
+    } catch (error) {
+      clearTimeout(timeoutId);
+      console.error("Error handling MCP request:", error);
+      sendErrorResponse(res, -32603, "Internal server error");
+      await cleanup();
+    }
+  });
+
+  const httpServer = app
+    .listen(HTTP_PORT, () => {
+      console.error(`Qdrant MCP server running on http://localhost:${HTTP_PORT}/mcp`);
+    })
+    .on("error", (error) => {
+      console.error("HTTP server error:", error);
+      process.exit(1);
+    });
+
+  // Graceful shutdown handling
+  let isShuttingDown = false;
+
+  const shutdown = () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
+    console.error("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");
+      process.exit(1);
+    }, SHUTDOWN_GRACE_PERIOD_MS);
+
+    httpServer.close(() => {
+      clearTimeout(forceTimeout);
+      console.error("HTTP server closed");
+      process.exit(0);
+    });
+  };
+
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+
+// Main entry point
+async function main() {
+  if (TRANSPORT_MODE === "http") {
+    await startHttpServer();
+  } else if (TRANSPORT_MODE === "stdio") {
+    await startStdioServer();
+  } else {
+    console.error(
+      `Error: Invalid TRANSPORT_MODE "${TRANSPORT_MODE}". Supported modes: stdio, http.`
+    );
+    process.exit(1);
+  }
+}
+
 main().catch((error) => {
   console.error("Fatal error:", error);
   process.exit(1);