@mhalder/qdrant-mcp-server 2.1.0 → 2.1.1

package/build/index.js

@@ -2,20 +2,19 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import Bottleneck from "bottleneck";
 import express from "express";
-import { z } from "zod";
 import { DEFAULT_BATCH_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_CODE_EXTENSIONS, DEFAULT_IGNORE_PATTERNS, DEFAULT_SEARCH_LIMIT, } from "./code/config.js";
 import { CodeIndexer } from "./code/indexer.js";
 import { EmbeddingProviderFactory } from "./embeddings/factory.js";
-import { BM25SparseVectorGenerator } from "./embeddings/sparse.js";
-import { getPrompt, listPrompts, loadPromptsConfig, } from "./prompts/index.js";
-import { renderTemplate, validateArguments } from "./prompts/template.js";
+import { loadPromptsConfig } from "./prompts/index.js";
+import { registerAllPrompts } from "./prompts/register.js";
 import { QdrantManager } from "./qdrant/client.js";
+import { registerAllResources } from "./resources/index.js";
+import { registerAllTools } from "./tools/index.js";
 // Read package.json for version
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
@@ -145,833 +144,32 @@ if (existsSync(PROMPTS_CONFIG_FILE)) {
         process.exit(1);
     }
 }
-// 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() {
-    const capabilities = {
-        tools: {},
-        resources: {},
-    };
-    // Only add prompts capability if prompts are configured
-    if (promptsConfig) {
-        capabilities.prompts = {};
-    }
-    return new Server({
-        name: pkg.name,
-        version: pkg.version,
-    }, {
-        capabilities,
-    });
-}
-// Create a shared MCP server for stdio mode
-const server = createServer();
-// Function to register all handlers on a server instance
-function registerHandlers(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"],
-                    },
-                },
-                {
-                    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: ["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",
-                            },
-                        },
-                        required: ["collection", "query"],
-                    },
-                },
-                {
-                    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",
-                            },
-                        },
-                        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",
-                            },
-                        },
-                        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"],
-                                },
-                            },
-                        },
-                        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",
-                            },
-                        },
-                        required: ["collection", "query"],
-                    },
-                },
-                {
-                    name: "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: {
-                        type: "object",
-                        properties: {
-                            path: {
-                                type: "string",
-                                description: "Absolute or relative path to codebase root directory",
-                            },
-                            forceReindex: {
-                                type: "boolean",
-                                description: "Force full re-index even if already indexed (default: false)",
-                            },
-                            extensions: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Custom file extensions to index (e.g., ['.proto', '.graphql'])",
-                            },
-                            ignorePatterns: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Additional patterns to ignore (e.g., ['**/test/**', '**/*.test.ts'])",
-                            },
-                        },
-                        required: ["path"],
-                    },
-                },
-                {
-                    name: "search_code",
-                    description: "Search indexed codebase using natural language queries. Returns semantically relevant code chunks with file paths and line numbers.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            path: {
-                                type: "string",
-                                description: "Path to codebase (must be indexed first)",
-                            },
-                            query: {
-                                type: "string",
-                                description: "Natural language search query (e.g., 'authentication logic')",
-                            },
-                            limit: {
-                                type: "number",
-                                description: "Maximum number of results (default: 5, max: 100)",
-                            },
-                            fileTypes: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Filter by file extensions (e.g., ['.ts', '.py'])",
-                            },
-                            pathPattern: {
-                                type: "string",
-                                description: "Filter by path glob pattern (e.g., 'src/services/**')",
-                            },
-                        },
-                        required: ["path", "query"],
-                    },
-                },
-                {
-                    name: "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: {
-                        type: "object",
-                        properties: {
-                            path: {
-                                type: "string",
-                                description: "Path to codebase",
-                            },
-                        },
-                        required: ["path"],
-                    },
-                },
-                {
-                    name: "get_index_status",
-                    description: "Get indexing status and statistics for a codebase.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            path: {
-                                type: "string",
-                                description: "Path to codebase",
-                            },
-                        },
-                        required: ["path"],
-                    },
-                },
-                {
-                    name: "clear_index",
-                    description: "Delete all indexed data for a codebase. This is irreversible and will remove the entire collection.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {
-                            path: {
-                                type: "string",
-                                description: "Path to codebase",
-                            },
-                        },
-                        required: ["path"],
-                    },
-                },
-            ],
-        };
-    });
-    // 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);
-                    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,
-                            },
-                        ],
-                    };
-                }
-                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,
-                            },
-                        }));
-                        await qdrant.addPoints(collection, points);
-                    }
-                    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) {
-                        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(collection, embedding, limit || 5, filter);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify(results, null, 2),
-                            },
-                        ],
-                    };
-                }
-                case "list_collections": {
-                    const collections = await qdrant.listCollections();
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify(collections, null, 2),
-                            },
-                        ],
-                    };
-                }
-                case "delete_collection": {
-                    const { name } = DeleteCollectionSchema.parse(args);
-                    await qdrant.deleteCollection(name);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Collection "${name}" deleted successfully.`,
-                            },
-                        ],
-                    };
-                }
-                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 "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 "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,
-                        };
-                    }
-                    // 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),
-                            },
-                        ],
-                    };
-                }
-                case "index_codebase": {
-                    const IndexCodebaseSchema = z.object({
-                        path: z.string(),
-                        forceReindex: z.boolean().optional(),
-                        extensions: z.array(z.string()).optional(),
-                        ignorePatterns: z.array(z.string()).optional(),
-                    });
-                    const { path, forceReindex, extensions, ignorePatterns } = IndexCodebaseSchema.parse(args);
-                    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",
-                    };
-                }
-                case "search_code": {
-                    const SearchCodeSchema = z.object({
-                        path: z.string(),
-                        query: z.string(),
-                        limit: z.number().optional(),
-                        fileTypes: z.array(z.string()).optional(),
-                        pathPattern: z.string().optional(),
-                    });
-                    const { path, query, limit, fileTypes, pathPattern } = SearchCodeSchema.parse(args);
-                    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}`,
-                            },
-                        ],
-                    };
-                }
-                case "get_index_status": {
-                    const GetIndexStatusSchema = z.object({
-                        path: z.string(),
-                    });
-                    const { path } = GetIndexStatusSchema.parse(args);
-                    const status = await codeIndexer.getIndexStatus(path);
-                    if (!status.isIndexed) {
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: `Codebase at "${path}" is not indexed. Use index_codebase to index it first.`,
-                                },
-                            ],
-                        };
-                    }
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify(status, null, 2),
-                            },
-                        ],
-                    };
-                }
-                case "reindex_changes": {
-                    const ReindexChangesSchema = z.object({
-                        path: z.string(),
-                    });
-                    const { path } = ReindexChangesSchema.parse(args);
-                    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,
-                            },
-                        ],
-                    };
-                }
-                case "clear_index": {
-                    const ClearIndexSchema = z.object({
-                        path: z.string(),
-                    });
-                    const { path } = ClearIndexSchema.parse(args);
-                    await codeIndexer.clearIndex(path);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Index cleared for codebase at "${path}".`,
-                            },
-                        ],
-                    };
-                }
-                default:
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Unknown tool: ${name}`,
-                            },
-                        ],
-                        isError: true,
-                    };
-            }
-        }
-        catch (error) {
-            // 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") {
-            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),
-                    },
-                ],
-            };
-        }
-        return {
-            contents: [
-                {
-                    uri,
-                    mimeType: "text/plain",
-                    text: `Unknown resource: ${uri}`,
-                },
-            ],
-        };
-    });
-    // List available prompts
-    if (promptsConfig) {
-        server.setRequestHandler(ListPromptsRequestSchema, async () => {
-            const prompts = listPrompts(promptsConfig);
-            return {
-                prompts: prompts.map((prompt) => ({
-                    name: prompt.name,
-                    description: prompt.description,
-                    arguments: prompt.arguments.map((arg) => ({
-                        name: arg.name,
-                        description: arg.description,
-                        required: arg.required,
-                    })),
-                })),
-            };
+// Function to create and configure a new MCP server instance
+function createAndConfigureServer() {
+    try {
+        const server = new McpServer({
+            name: pkg.name,
+            version: pkg.version,
         });
-        // Get prompt content
-        server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            const prompt = getPrompt(promptsConfig, name);
-            if (!prompt) {
-                throw new Error(`Unknown prompt: ${name}`);
-            }
-            try {
-                // Validate arguments
-                validateArguments(args || {}, prompt.arguments);
-                // Render template
-                const rendered = renderTemplate(prompt.template, args || {}, prompt.arguments);
-                return {
-                    messages: [
-                        {
-                            role: "user",
-                            content: {
-                                type: "text",
-                                text: rendered.text,
-                            },
-                        },
-                    ],
-                };
-            }
-            catch (error) {
-                throw new Error(`Failed to render prompt "${name}": ${error instanceof Error ? error.message : String(error)}`);
-            }
+        // Register all tools
+        registerAllTools(server, {
+            qdrant,
+            embeddings,
+            codeIndexer,
         });
+        // Register all resources
+        registerAllResources(server, qdrant);
+        // Register all prompts (if configured)
+        registerAllPrompts(server, promptsConfig);
+        return server;
+    }
+    catch (error) {
+        console.error("Failed to configure MCP server:", error);
+        throw error;
     }
 }
-// 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)"),
-});
-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"),
-});
+// Create a shared MCP server for stdio mode
+const server = createAndConfigureServer();
 // Start server with stdio transport
 async function startStdioServer() {
     await checkOllamaAvailability();
@@ -1067,8 +265,7 @@ async function startHttpServer() {
     });
     app.post("/mcp", rateLimitMiddleware, async (req, res) => {
         // Create a new server for each request
-        const requestServer = createServer();
-        registerHandlers(requestServer);
+        const requestServer = createAndConfigureServer();
         // Create transport with enableJsonResponse
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: undefined,