mcp-mongo-server 0.2.0 → 1.1.0

package/README.md

@@ -5,7 +5,7 @@
 ![NPM License](https://img.shields.io/npm/l/mcp-mongo-server)
 [![smithery badge](https://smithery.ai/badge/mcp-mongo-server)](https://smithery.ai/server/mcp-mongo-server)
 
-A Model Context Protocol server that provides access to MongoDB databases. This server enables LLMs to inspect collection schemas and execute read-only queries.
+A Model Context Protocol server that provides access to MongoDB databases. This server enables LLMs to inspect collection schemas and execute MongoDB operations.
 
 ## Demo
 
@@ -20,23 +20,44 @@ A Model Context Protocol server that provides access to MongoDB databases. This
 
 ### Tools
 - **query**
-  - Execute read-only MongoDB queries against the connected database
-  - Input: `query` (object): The MongoDB query to execute
-  - All queries are executed with read-only permissions
+  - Execute MongoDB queries with optional execution plan analysis
+  - Input: Collection name, filter, projection, limit, explain options
+  - Returns query results or execution plan
 
 - **aggregate**
-  - Execute read-only MongoDB queries against the connected database
-  - Input: `aggregate` (object): The MongoDB query to execute
-  - All queries are executed with read-only permissions
+  - Execute MongoDB aggregation pipelines with optional execution plan analysis
+  - Input: Collection name, pipeline stages, explain options
+  - Returns aggregation results or execution plan
+
+- **update**
+  - Update documents in a collection
+  - Input: Collection name, filter, update operations, upsert/multi options
+  - Returns update operation results
+
+- **serverInfo**
+  - Get MongoDB server information and status
+  - Input: Optional debug info flag
+  - Returns version, storage engine, and server details
+
+- **insert**
+  - Insert documents into a collection
+  - Input: Collection name, documents array, write options
+  - Returns insert operation results
+
+- **createIndex**
+  - Create indexes on a collection
+  - Input: Collection name, index specifications, write options
+  - Returns index creation results
+
+- **count**
+  - Count documents matching a query
+  - Input: Collection name, query filter, count options
+  - Returns document count
 
 ### Prompts
-- `query` - Provide insights about the collection's structure, data types, and basic statistics
-  - Input: `collection` (string): The name of the collection to analyze
-  - Output: `text` (string): A summary of the collection's structure, data types, and basic statistics
-- `aggregate` - Provide insights about the collection's structure, data types, and basic statistics
-  - Input: `collection` (string): The name of the collection to analyze
-  - Output: `text` (string): A summary of the collection's structure, data types, and basic statistics
-
+- `analyze_collection` - Analyze collection structure and contents
+  - Input: Collection name
+  - Output: Insights about schema, data types, and statistics
 
 
 ## Development

package/build/index.js

@@ -9,8 +9,8 @@
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { MongoClient, ServerApiVersion } from "mongodb";
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, PingRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { MongoClient } from "mongodb";
 /**
  * MongoDB connection client and database reference
  */
@@ -22,7 +22,7 @@ let db = null;
  */
 const server = new Server({
     name: "mongodb",
-    version: "0.2.0",
+    version: "1.1.0",
 }, {
     capabilities: {
         resources: {},
@@ -35,13 +35,7 @@ const server = new Server({
  */
 async function connectToMongoDB(url) {
     try {
-        client = new MongoClient(url, {
-            serverApi: {
-                version: ServerApiVersion.v1,
-                strict: true,
-                deprecationErrors: true,
-            },
-        });
+        client = new MongoClient(url);
         await client.connect();
         db = client.db();
         return true;
@@ -51,6 +45,26 @@ async function connectToMongoDB(url) {
         return false;
     }
 }
+/**
+ * Handler for ping requests to check server health
+ */
+server.setRequestHandler(PingRequestSchema, async () => {
+    try {
+        // Check MongoDB connection
+        if (!client) {
+            throw new Error("MongoDB connection is not available");
+        }
+        // Ping MongoDB to verify connection
+        await db.command({ ping: 1 });
+        return {};
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`MongoDB ping failed: ${error.message}`);
+        }
+        throw new Error("MongoDB ping failed: Unknown error");
+    }
+});
 /**
  * Handler for listing available collections as resources.
  * Each collection is exposed as a resource with:
@@ -74,7 +88,7 @@ server.setRequestHandler(ListResourcesRequestSchema, async () => {
         if (error instanceof Error) {
             throw new Error(`Failed to list collections: ${error.message}`);
         }
-        throw new Error('Failed to list collections: Unknown error');
+        throw new Error("Failed to list collections: Unknown error");
     }
 });
 /**
@@ -89,29 +103,33 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         const sample = await collection.findOne({});
         const indexes = await collection.indexes();
         // Infer schema from sample document
-        const schema = sample ? {
-            type: "collection",
-            name: collectionName,
-            fields: Object.entries(sample).map(([key, value]) => ({
-                name: key,
-                type: typeof value,
-            })),
-            indexes: indexes.map((idx) => ({
-                name: idx.name,
-                keys: idx.key,
-            })),
-        } : {
-            type: "collection",
-            name: collectionName,
-            fields: [],
-            indexes: [],
-        };
+        const schema = sample
+            ? {
+                type: "collection",
+                name: collectionName,
+                fields: Object.entries(sample).map(([key, value]) => ({
+                    name: key,
+                    type: typeof value,
+                })),
+                indexes: indexes.map((idx) => ({
+                    name: idx.name,
+                    keys: idx.key,
+                })),
+            }
+            : {
+                type: "collection",
+                name: collectionName,
+                fields: [],
+                indexes: [],
+            };
         return {
-            contents: [{
+            contents: [
+                {
                     uri: request.params.uri,
                     mimeType: "application/json",
-                    text: JSON.stringify(schema, null, 2)
-                }]
+                    text: JSON.stringify(schema, null, 2),
+                },
+            ],
         };
     }
     catch (error) {
@@ -130,49 +148,254 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         tools: [
             {
                 name: "query",
-                description: "Execute a MongoDB query",
+                description: "Execute a MongoDB query with optional execution plan analysis",
                 inputSchema: {
                     type: "object",
                     properties: {
                         collection: {
                             type: "string",
-                            description: "Name of the collection to query"
+                            description: "Name of the collection to query",
                         },
                         filter: {
                             type: "object",
-                            description: "MongoDB query filter"
+                            description: "MongoDB query filter",
                         },
                         projection: {
                             type: "object",
-                            description: "Fields to include/exclude"
+                            description: "Fields to include/exclude",
                         },
                         limit: {
                             type: "number",
-                            description: "Maximum number of documents to return"
-                        }
+                            description: "Maximum number of documents to return",
+                        },
+                        explain: {
+                            type: "string",
+                            description: "Optional: Get query execution information (queryPlanner, executionStats, or allPlansExecution)",
+                            enum: ["queryPlanner", "executionStats", "allPlansExecution"],
+                        },
                     },
-                    required: ["collection"]
-                }
+                    required: ["collection"],
+                },
             },
             {
                 name: "aggregate",
-                description: "Execute a MongoDB aggregation pipeline",
+                description: "Execute a MongoDB aggregation pipeline with optional execution plan analysis",
                 inputSchema: {
                     type: "object",
                     properties: {
                         collection: {
                             type: "string",
-                            description: "Name of the collection to aggregate"
+                            description: "Name of the collection to aggregate",
                         },
                         pipeline: {
                             type: "array",
-                            description: "Aggregation pipeline stages"
-                        }
+                            description: "Aggregation pipeline stages",
+                        },
+                        explain: {
+                            type: "string",
+                            description: "Optional: Get aggregation execution information (queryPlanner, executionStats, or allPlansExecution)",
+                            enum: ["queryPlanner", "executionStats", "allPlansExecution"],
+                        },
+                    },
+                    required: ["collection", "pipeline"],
+                },
+            },
+            {
+                name: "update",
+                description: "Update documents in a MongoDB collection",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        collection: {
+                            type: "string",
+                            description: "Name of the collection to update",
+                        },
+                        filter: {
+                            type: "object",
+                            description: "Filter to select documents to update",
+                        },
+                        update: {
+                            type: "object",
+                            description: "Update operations to apply ($set, $unset, $inc, etc.)",
+                        },
+                        upsert: {
+                            type: "boolean",
+                            description: "Create a new document if no documents match the filter",
+                        },
+                        multi: {
+                            type: "boolean",
+                            description: "Update multiple documents that match the filter",
+                        },
                     },
-                    required: ["collection", "pipeline"]
+                    required: ["collection", "filter", "update"],
+                },
+            },
+            {
+                name: "serverInfo",
+                description: "Get MongoDB server information including version, storage engine, and other details",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        includeDebugInfo: {
+                            type: "boolean",
+                            description: "Include additional debug information about the server",
+                        },
+                    },
+                },
+            },
+            {
+                name: "insert",
+                description: "Insert one or more documents into a MongoDB collection",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        collection: {
+                            type: "string",
+                            description: "Name of the collection to insert into",
+                        },
+                        documents: {
+                            type: "array",
+                            description: "Array of documents to insert",
+                            items: {
+                                type: "object",
+                            },
+                        },
+                        ordered: {
+                            type: "boolean",
+                            description: "Optional: If true, perform an ordered insert of the documents. If false, perform an unordered insert",
+                        },
+                        writeConcern: {
+                            type: "object",
+                            description: "Optional: Write concern for the insert operation",
+                        },
+                        bypassDocumentValidation: {
+                            type: "boolean",
+                            description: "Optional: Allow insert to bypass schema validation",
+                        },
+                    },
+                    required: ["collection", "documents"],
+                },
+            },
+            {
+                name: "createIndex",
+                description: "Create one or more indexes on a MongoDB collection",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        collection: {
+                            type: "string",
+                            description: "Name of the collection to create indexes on",
+                        },
+                        indexes: {
+                            type: "array",
+                            description: "Array of index specifications",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    key: {
+                                        type: "object",
+                                        description: "Index key pattern, e.g. { field: 1 } for ascending, { field: -1 } for descending",
+                                    },
+                                    name: {
+                                        type: "string",
+                                        description: "Optional: Name of the index",
+                                    },
+                                    unique: {
+                                        type: "boolean",
+                                        description: "Optional: If true, creates a unique index",
+                                    },
+                                    sparse: {
+                                        type: "boolean",
+                                        description: "Optional: If true, creates a sparse index",
+                                    },
+                                    background: {
+                                        type: "boolean",
+                                        description: "Optional: If true, creates the index in the background",
+                                    },
+                                    expireAfterSeconds: {
+                                        type: "number",
+                                        description: "Optional: Specifies the TTL for documents (time to live)",
+                                    },
+                                    partialFilterExpression: {
+                                        type: "object",
+                                        description: "Optional: Filter expression for partial indexes",
+                                    },
+                                },
+                                required: ["key"],
+                            },
+                        },
+                        writeConcern: {
+                            type: "object",
+                            description: "Optional: Write concern for the index creation",
+                        },
+                        commitQuorum: {
+                            type: ["string", "number"],
+                            description: "Optional: Number of voting members required to create index",
+                        },
+                    },
+                    required: ["collection", "indexes"],
+                },
+            },
+            {
+                name: "count",
+                description: "Count the number of documents in a collection that match a query",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        collection: {
+                            type: "string",
+                            description: "Name of the collection to count documents in",
+                        },
+                        query: {
+                            type: "object",
+                            description: "Optional: Query filter to select documents to count",
+                        },
+                        limit: {
+                            type: "integer",
+                            description: "Optional: Maximum number of documents to count",
+                        },
+                        skip: {
+                            type: "integer",
+                            description: "Optional: Number of documents to skip before counting",
+                        },
+                        hint: {
+                            type: "object",
+                            description: "Optional: Index hint to force query plan",
+                        },
+                        readConcern: {
+                            type: "object",
+                            description: "Optional: Read concern for the count operation",
+                        },
+                        maxTimeMS: {
+                            type: "integer",
+                            description: "Optional: Maximum time to allow the count to run",
+                        },
+                        collation: {
+                            type: "object",
+                            description: "Optional: Collation rules for string comparison",
+                        },
+                    },
+                    required: ["collection"],
+                },
+            },
+            {
+                name: "listCollections",
+                description: "List all collections in the MongoDB database",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        nameOnly: {
+                            type: "boolean",
+                            description: "Optional: If true, returns only the collection names instead of full collection info"
+                        },
+                        filter: {
+                            type: "object",
+                            description: "Optional: Filter to apply to the collections"
+                        }
+                    }
                 }
-            }
-        ]
+            },
+        ],
     };
 });
 /**
@@ -183,42 +406,66 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const collection = db.collection(request.params.arguments?.collection);
     switch (request.params.name) {
         case "query": {
-            const { filter, projection, limit } = request.params.arguments || {};
+            const { filter, projection, limit, explain } = request.params.arguments || {};
             // Validate collection name to prevent access to system collections
-            if (collection.collectionName.startsWith('system.')) {
-                throw new Error('Access to system collections is not allowed');
+            if (collection.collectionName.startsWith("system.")) {
+                throw new Error("Access to system collections is not allowed");
             }
             // Validate and parse filter
             let queryFilter = {};
             if (filter) {
-                if (typeof filter === 'string') {
+                if (typeof filter === "string") {
                     try {
                         queryFilter = JSON.parse(filter);
                     }
                     catch (e) {
-                        throw new Error('Invalid filter format: must be a valid JSON object');
+                        throw new Error("Invalid filter format: must be a valid JSON object");
                     }
                 }
-                else if (typeof filter === 'object' && filter !== null && !Array.isArray(filter)) {
+                else if (typeof filter === "object" &&
+                    filter !== null &&
+                    !Array.isArray(filter)) {
                     queryFilter = filter;
                 }
                 else {
-                    throw new Error('Query filter must be a plain object or ObjectId');
+                    throw new Error("Query filter must be a plain object or ObjectId");
                 }
             }
             // Execute the find operation with error handling
             try {
-                const cursor = collection.find(queryFilter, {
-                    projection,
-                    limit: limit || 100
-                });
-                const results = await cursor.toArray();
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify(results, null, 2)
-                        }]
-                };
+                if (explain) {
+                    // Use explain for query analysis
+                    const explainResult = await collection
+                        .find(queryFilter, {
+                        projection,
+                        limit: limit || 100,
+                    })
+                        .explain(explain);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(explainResult, null, 2),
+                            },
+                        ],
+                    };
+                }
+                else {
+                    // Regular query execution
+                    const cursor = collection.find(queryFilter, {
+                        projection,
+                        limit: limit || 100,
+                    });
+                    const results = await cursor.toArray();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(results, null, 2),
+                            },
+                        ],
+                    };
+                }
             }
             catch (error) {
                 if (error instanceof Error) {
@@ -228,33 +475,392 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
         }
         case "aggregate": {
-            const { pipeline } = request.params.arguments || {};
+            const { pipeline, explain } = request.params.arguments || {};
             if (!Array.isArray(pipeline)) {
                 throw new Error("Pipeline must be an array");
             }
             // Validate collection name to prevent access to system collections
-            if (collection.collectionName.startsWith('system.')) {
-                throw new Error('Access to system collections is not allowed');
+            if (collection.collectionName.startsWith("system.")) {
+                throw new Error("Access to system collections is not allowed");
             }
             // Execute the aggregation operation with error handling
             try {
-                const results = await collection.aggregate(pipeline).toArray();
+                if (explain) {
+                    // Use explain for aggregation analysis
+                    const explainResult = await collection
+                        .aggregate(pipeline, {
+                        explain: {
+                            verbosity: explain,
+                        },
+                    })
+                        .toArray();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(explainResult, null, 2),
+                            },
+                        ],
+                    };
+                }
+                else {
+                    // Regular aggregation execution
+                    const results = await collection.aggregate(pipeline).toArray();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(results, null, 2),
+                            },
+                        ],
+                    };
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to aggregate collection ${collection.collectionName}: ${error.message}`);
+                }
+                throw new Error(`Failed to aggregate collection ${collection.collectionName}: Unknown error`);
+            }
+        }
+        case "update": {
+            const { filter, update, upsert, multi } = request.params.arguments || {};
+            // Validate collection name to prevent access to system collections
+            if (collection.collectionName.startsWith("system.")) {
+                throw new Error("Access to system collections is not allowed");
+            }
+            // Validate and parse filter
+            let queryFilter = {};
+            if (filter) {
+                if (typeof filter === "string") {
+                    try {
+                        queryFilter = JSON.parse(filter);
+                    }
+                    catch (e) {
+                        throw new Error("Invalid filter format: must be a valid JSON object");
+                    }
+                }
+                else if (typeof filter === "object" &&
+                    filter !== null &&
+                    !Array.isArray(filter)) {
+                    queryFilter = filter;
+                }
+                else {
+                    throw new Error("Query filter must be a plain object or ObjectId");
+                }
+            }
+            // Validate update operations
+            if (!update || typeof update !== "object" || Array.isArray(update)) {
+                throw new Error("Update must be a valid MongoDB update document");
+            }
+            // Check if update operations use valid operators
+            const validUpdateOperators = [
+                "$set",
+                "$unset",
+                "$inc",
+                "$push",
+                "$pull",
+                "$addToSet",
+                "$pop",
+                "$rename",
+                "$mul",
+            ];
+            const hasValidOperator = Object.keys(update).some((key) => validUpdateOperators.includes(key));
+            if (!hasValidOperator) {
+                throw new Error("Update must include at least one valid update operator ($set, $unset, etc.)");
+            }
+            try {
+                const options = {
+                    upsert: !!upsert,
+                    multi: !!multi,
+                };
+                // Use updateOne or updateMany based on multi option
+                const updateMethod = options.multi ? "updateMany" : "updateOne";
+                const result = await collection[updateMethod](queryFilter, update, options);
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: "text",
-                            text: JSON.stringify(results, null, 2)
-                        }]
+                            text: JSON.stringify({
+                                matchedCount: result.matchedCount,
+                                modifiedCount: result.modifiedCount,
+                                upsertedCount: result.upsertedCount,
+                                upsertedId: result.upsertedId,
+                            }, null, 2),
+                        },
+                    ],
                 };
             }
             catch (error) {
                 if (error instanceof Error) {
-                    throw new Error(`Failed to aggregate collection ${collection.collectionName}: ${error.message}`);
+                    throw new Error(`Failed to update collection ${collection.collectionName}: ${error.message}`);
                 }
-                throw new Error(`Failed to aggregate collection ${collection.collectionName}: Unknown error`);
+                throw new Error(`Failed to update collection ${collection.collectionName}: Unknown error`);
+            }
+        }
+        case "serverInfo": {
+            const { includeDebugInfo } = request.params.arguments || {};
+            try {
+                // Get basic server information using buildInfo command
+                const buildInfo = await db.command({ buildInfo: 1 });
+                // Get additional server status if debug info is requested
+                let serverStatus = null;
+                if (includeDebugInfo) {
+                    serverStatus = await db.command({ serverStatus: 1 });
+                }
+                // Construct the response
+                const serverInfo = {
+                    version: buildInfo.version,
+                    gitVersion: buildInfo.gitVersion,
+                    modules: buildInfo.modules,
+                    allocator: buildInfo.allocator,
+                    javascriptEngine: buildInfo.javascriptEngine,
+                    sysInfo: buildInfo.sysInfo,
+                    storageEngines: buildInfo.storageEngines,
+                    debug: buildInfo.debug,
+                    maxBsonObjectSize: buildInfo.maxBsonObjectSize,
+                    openssl: buildInfo.openssl,
+                    buildEnvironment: buildInfo.buildEnvironment,
+                    bits: buildInfo.bits,
+                    ok: buildInfo.ok,
+                    status: {},
+                };
+                // Add server status information if requested
+                if (serverStatus) {
+                    serverInfo.status = {
+                        host: serverStatus.host,
+                        version: serverStatus.version,
+                        process: serverStatus.process,
+                        pid: serverStatus.pid,
+                        uptime: serverStatus.uptime,
+                        uptimeMillis: serverStatus.uptimeMillis,
+                        uptimeEstimate: serverStatus.uptimeEstimate,
+                        localTime: serverStatus.localTime,
+                        connections: serverStatus.connections,
+                        network: serverStatus.network,
+                        memory: serverStatus.mem,
+                        storageEngine: serverStatus.storageEngine,
+                        security: serverStatus.security,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(serverInfo, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to get server information: ${error.message}`);
+                }
+                throw new Error("Failed to get server information: Unknown error");
+            }
+        }
+        case "insert": {
+            const { documents, ordered, writeConcern, bypassDocumentValidation } = request.params.arguments || {};
+            // Validate collection name to prevent access to system collections
+            if (collection.collectionName.startsWith("system.")) {
+                throw new Error("Access to system collections is not allowed");
+            }
+            // Validate documents array
+            if (!Array.isArray(documents)) {
+                throw new Error("Documents must be an array");
+            }
+            if (documents.length === 0) {
+                throw new Error("Documents array cannot be empty");
+            }
+            if (!documents.every((doc) => doc && typeof doc === "object" && !Array.isArray(doc))) {
+                throw new Error("Each document must be a valid MongoDB document object");
+            }
+            try {
+                // Prepare insert options
+                const options = {
+                    ordered: ordered !== false, // default to true if not specified
+                    writeConcern,
+                    bypassDocumentValidation,
+                };
+                // Use insertMany for consistency, it works for single documents too
+                const result = await collection.insertMany(documents, options);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                acknowledged: result.acknowledged,
+                                insertedCount: result.insertedCount,
+                                insertedIds: result.insertedIds,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    // Handle bulk write errors specially to provide more detail
+                    if (error.name === "BulkWriteError") {
+                        const bulkError = error;
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        error: "Bulk write error occurred",
+                                        writeErrors: bulkError.writeErrors,
+                                        insertedCount: bulkError.result?.nInserted || 0,
+                                        failedCount: bulkError.result?.nFailedInserts || 0,
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
+                    throw new Error(`Failed to insert documents into collection ${collection.collectionName}: ${error.message}`);
+                }
+                throw new Error(`Failed to insert documents into collection ${collection.collectionName}: Unknown error`);
+            }
+        }
+        case "createIndex": {
+            const { indexes, writeConcern, commitQuorum } = request.params.arguments || {};
+            // Validate collection name to prevent access to system collections
+            if (collection.collectionName.startsWith("system.")) {
+                throw new Error("Access to system collections is not allowed");
+            }
+            // Validate indexes array
+            if (!Array.isArray(indexes) || indexes.length === 0) {
+                throw new Error("Indexes must be a non-empty array");
+            }
+            // Validate writeConcern
+            if (writeConcern &&
+                (typeof writeConcern !== "object" || Array.isArray(writeConcern))) {
+                throw new Error("Write concern must be a valid MongoDB write concern object");
+            }
+            // Validate commitQuorum
+            if (commitQuorum &&
+                typeof commitQuorum !== "string" &&
+                typeof commitQuorum !== "number") {
+                throw new Error("Commit quorum must be a string or number");
+            }
+            try {
+                const result = await collection.createIndexes(indexes, {
+                    writeConcern,
+                    commitQuorum: typeof commitQuorum === "number" ? commitQuorum : undefined,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                acknowledged: result.acknowledged,
+                                createdIndexes: result.createdIndexes,
+                                numIndexesBefore: result.numIndexesBefore,
+                                numIndexesAfter: result.numIndexesAfter,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to create indexes on collection ${collection.collectionName}: ${error.message}`);
+                }
+                throw new Error(`Failed to create indexes on collection ${collection.collectionName}: Unknown error`);
+            }
+        }
+        case "count": {
+            const args = request.params.arguments || {};
+            const { query } = args;
+            // Validate collection name to prevent access to system collections
+            if (collection.collectionName.startsWith("system.")) {
+                throw new Error("Access to system collections is not allowed");
+            }
+            // Validate and parse query
+            let countQuery = {};
+            if (query) {
+                if (typeof query === "string") {
+                    try {
+                        countQuery = JSON.parse(query);
+                    }
+                    catch (e) {
+                        throw new Error("Invalid query format: must be a valid JSON object");
+                    }
+                }
+                else if (typeof query === "object" &&
+                    query !== null &&
+                    !Array.isArray(query)) {
+                    countQuery = query;
+                }
+                else {
+                    throw new Error("Query must be a plain object");
+                }
+            }
+            try {
+                const options = {
+                    limit: typeof args.limit === "number" ? args.limit : undefined,
+                    skip: typeof args.skip === "number" ? args.skip : undefined,
+                    hint: typeof args.hint === "object" && args.hint !== null
+                        ? args.hint
+                        : undefined,
+                    readConcern: typeof args.readConcern === "object" && args.readConcern !== null
+                        ? args.readConcern
+                        : undefined,
+                    maxTimeMS: typeof args.maxTimeMS === "number" ? args.maxTimeMS : undefined,
+                    collation: typeof args.collation === "object" && args.collation !== null
+                        ? args.collation
+                        : undefined,
+                };
+                // Remove undefined options
+                Object.keys(options).forEach((key) => options[key] === undefined && delete options[key]);
+                // Execute count operation
+                const count = await collection.countDocuments(countQuery, options);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                count: count,
+                                ok: 1,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to count documents in collection ${collection.collectionName}: ${error.message}`);
+                }
+                throw new Error(`Failed to count documents in collection ${collection.collectionName}: Unknown error`);
+            }
+        }
+        case "listCollections": {
+            const { nameOnly, filter } = request.params.arguments || {};
+            try {
+                // Get the list of collections
+                const options = filter ? { filter } : {};
+                const collections = await db.listCollections(options).toArray();
+                // If nameOnly is true, return only the collection names
+                const result = nameOnly
+                    ? collections.map((collection) => collection.name)
+                    : collections;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw new Error(`Failed to list collections: ${error.message}`);
+                }
+                throw new Error("Failed to list collections: Unknown error");
             }
         }
         default:
-            throw new Error("Unknown tool");
+            throw new Error(`Unknown tool: ${request.params.name}`);
     }
 });
 /**
@@ -271,11 +877,11 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
                     {
                         name: "collection",
                         description: "Name of the collection to analyze",
-                        required: true
-                    }
-                ]
-            }
-        ]
+                        required: true,
+                    },
+                ],
+            },
+        ],
     };
 });
 /**
@@ -293,22 +899,22 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
     try {
         const collection = db.collection(collectionName);
         // Validate collection name to prevent access to system collections
-        if (collection.collectionName.startsWith('system.')) {
-            throw new Error('Access to system collections is not allowed');
+        if (collection.collectionName.startsWith("system.")) {
+            throw new Error("Access to system collections is not allowed");
         }
         const schema = await collection.findOne({});
         // Get basic collection stats - just count in API v1
-        const stats = await collection.aggregate([
+        const stats = await collection
+            .aggregate([
             {
                 $collStats: {
-                    count: {}
-                }
-            }
-        ]).toArray();
-        // Also get a sample of documents to show data distribution
-        const sampleDocs = await collection.find({})
-            .limit(5)
+                    count: {},
+                },
+            },
+        ])
             .toArray();
+        // Also get a sample of documents to show data distribution
+        const sampleDocs = await collection.find({}).limit(5).toArray();
         return {
             messages: [
                 {
@@ -322,20 +928,20 @@ Schema:
 ${JSON.stringify(schema, null, 2)}
 
 Stats:
-Document count: ${stats[0]?.count || 'unknown'}
+Document count: ${stats[0]?.count || "unknown"}
 
 Sample documents:
-${JSON.stringify(sampleDocs, null, 2)}`
-                    }
+${JSON.stringify(sampleDocs, null, 2)}`,
+                    },
                 },
                 {
                     role: "user",
                     content: {
                         type: "text",
-                        text: "Provide insights about the collection's structure, data types, and basic statistics."
-                    }
-                }
-            ]
+                        text: "Provide insights about the collection's structure, data types, and basic statistics.",
+                    },
+                },
+            ],
         };
     }
     catch (error) {
@@ -379,9 +985,9 @@ Example queries:
 3. Find documents with existing email:
 { "email": { "$exists": true } }
 
-Use these patterns to construct MongoDB queries.`
-            }
-        ]
+Use these patterns to construct MongoDB queries.`,
+            },
+        ],
     };
 });
 /**

package/build/types.js

@@ -4,11 +4,13 @@ import { CallToolRequestSchema, ToolSchema, ResourceSchema, TextResourceContents
 export const MongoCollectionSchema = ResourceSchema.extend({
     collectionName: z.string(),
     databaseName: z.string(),
-    indexes: z.array(z.object({
+    indexes: z
+        .array(z.object({
         name: z.string(),
         keys: z.record(z.union([z.number(), z.string()])),
         unique: z.optional(z.boolean()),
-    })).optional(),
+    }))
+        .optional(),
 });
 // MongoDB Document Schema
 export const MongoDocumentSchema = TextResourceContentsSchema.extend({
@@ -40,14 +42,16 @@ export const MongoSortSchema = z.record(z.union([z.literal(1), z.literal(-1)]));
 export const MongoQueryToolSchema = ToolSchema.extend({
     inputSchema: z.object({
         type: z.literal("object"),
-        properties: z.object({
+        properties: z
+            .object({
             collection: z.string(),
             filter: z.record(z.union([z.unknown(), MongoQueryOperatorSchema])),
             projection: z.record(z.union([z.literal(0), z.literal(1)])).optional(),
             sort: MongoSortSchema.optional(),
             limit: z.number().int().positive().optional(),
             skip: z.number().int().nonnegative().optional(),
-        }).passthrough(),
+        })
+            .passthrough(),
         required: z.array(z.literal("collection")),
     }),
 });
@@ -55,10 +59,12 @@ export const MongoQueryToolSchema = ToolSchema.extend({
 export const MongoAggregateToolSchema = ToolSchema.extend({
     inputSchema: z.object({
         type: z.literal("object"),
-        properties: z.object({
+        properties: z
+            .object({
             collection: z.string(),
             pipeline: z.array(z.record(z.unknown())),
-        }).passthrough(),
+        })
+            .passthrough(),
         required: z.array(z.literal("collection")),
     }),
 });
@@ -66,10 +72,14 @@ export const MongoAggregateToolSchema = ToolSchema.extend({
 export const MongoCountToolSchema = ToolSchema.extend({
     inputSchema: z.object({
         type: z.literal("object"),
-        properties: z.object({
+        properties: z
+            .object({
             collection: z.string(),
-            filter: z.record(z.union([z.unknown(), MongoQueryOperatorSchema])).optional(),
-        }).passthrough(),
+            filter: z
+                .record(z.union([z.unknown(), MongoQueryOperatorSchema]))
+                .optional(),
+        })
+            .passthrough(),
         required: z.array(z.literal("collection")),
     }),
 });
@@ -77,18 +87,32 @@ export const MongoCountToolSchema = ToolSchema.extend({
 export const MongoDistinctToolSchema = ToolSchema.extend({
     inputSchema: z.object({
         type: z.literal("object"),
-        properties: z.object({
+        properties: z
+            .object({
             collection: z.string(),
             field: z.string(),
-            filter: z.record(z.union([z.unknown(), MongoQueryOperatorSchema])).optional(),
-        }).passthrough(),
+            filter: z
+                .record(z.union([z.unknown(), MongoQueryOperatorSchema]))
+                .optional(),
+        })
+            .passthrough(),
         required: z.array(z.literal("collection")),
     }),
 });
 // MongoDB Call Tool Request Schema
 export const MongoCallToolRequestSchema = CallToolRequestSchema.extend({
     params: z.object({
-        name: z.enum(["query", "aggregate", "count", "distinct"]),
+        name: z.enum([
+            "query",
+            "aggregate",
+            "update",
+            "serverInfo",
+            "insert",
+            "createIndex",
+            "count",
+            "distinct",
+            "listCollections",
+        ]),
         arguments: z.union([
             MongoQueryToolSchema.shape.inputSchema,
             MongoAggregateToolSchema.shape.inputSchema,
@@ -136,8 +160,10 @@ export const MongoFieldSchemaSchema = z.object({
 export const MongoCollectionSchemaSchema = z.object({
     name: z.string(),
     fields: z.record(MongoFieldSchemaSchema),
-    options: z.object({
+    options: z
+        .object({
         timestamps: z.boolean().optional(),
         strict: z.boolean().optional(),
-    }).optional(),
+    })
+        .optional(),
 });

package/package.json

@@ -1,52 +1,52 @@
 {
-  "name": "mcp-mongo-server",
-  "version": "0.2.0",
-  "description": "A Model Context Protocol server for MongoDB connections",
-  "private": false,
-  "type": "module",
-  "bin": {
-    "mongodb": "./build/index.js"
-  },
-  "files": [
-    "build"
-  ],
-  "scripts": {
-    "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
-    "prepare": "npm run build",
-    "watch": "tsc --watch",
-    "inspector": "npx @modelcontextprotocol/inspector build/index.js"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "0.6.0",
-    "@types/mongodb": "^4.0.6",
-    "mongodb": "^6.11.0",
-    "zod": "^3.23.8"
-  },
-  "devDependencies": {
-    "@types/node": "^20.11.24",
-    "typescript": "^5.3.3"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "claude",
-    "claude-desktop",
-    "mcp",
-    "mongo",
-    "mongodb",
-    "model-context-protocol",
-    "llm",
-    "mcp-server",
-    "mcp-protocol",
-    "mcp-connector",
-    "mcp-connector-mongodb"
-  ],
-  "author": "Muhammed Kilic <kiliczsh>",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/kiliczsh/mcp-mongo-server"
-  },
-  "homepage": "https://github.com/kiliczsh/mcp-mongo-server"
-}
+    "name": "mcp-mongo-server",
+    "version": "1.1.0",
+    "description": "A Model Context Protocol server for MongoDB connections",
+    "private": false,
+    "type": "module",
+    "bin": {
+        "mongodb": "./build/index.js"
+    },
+    "files": [
+        "build"
+    ],
+    "scripts": {
+        "build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
+        "prepare": "npm run build",
+        "watch": "tsc --watch",
+        "inspector": "npx @modelcontextprotocol/inspector build/index.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "0.6.0",
+        "@types/mongodb": "^4.0.6",
+        "mongodb": "^6.11.0",
+        "zod": "^3.23.8"
+    },
+    "devDependencies": {
+        "@types/node": "^20.11.24",
+        "typescript": "^5.3.3"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "keywords": [
+        "claude",
+        "claude-desktop",
+        "mcp",
+        "mongo",
+        "mongodb",
+        "model-context-protocol",
+        "llm",
+        "mcp-server",
+        "mcp-protocol",
+        "mcp-connector",
+        "mcp-connector-mongodb"
+    ],
+    "author": "Muhammed Kilic <kiliczsh>",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/kiliczsh/mcp-mongo-server"
+    },
+    "homepage": "https://github.com/kiliczsh/mcp-mongo-server"
+}