feat: add support for managing search indexes

Author: nirinchev

src/tools/mongodb/create/createSearchIndex.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { IndexDirection } from "mongodb";
+
+export class CreateSearchIndexTool extends MongoDBToolBase {
+    protected name = "create-search-index";
+    protected description = "Create an Atlas Search index for a collection";
+    protected argsShape = {
+        ...DbOperationArgs,
+        name: z.string().optional().describe("The name of the index"),
+        type: z.enum(["search", "vectorSearch"]).optional().default("search").describe("The type of the index"),
+        analyzer: z
+            .string()
+            .optional()
+            .default("lucene.standard")
+            .describe(
+                "The analyzer to use for the index. Can be one of the built-in lucene analyzers (`lucene.standard`, `lucene.simple`, `lucene.whitespace`, `lucene.keyword`), a language-specific analyzer, such as `lucene.cjk` or `lucene.czech`, or a custom analyzer defined in the Atlas UI."
+            ),
+        mappings: z.object({
+            dynamic: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe(
+                    "Enables or disables dynamic mapping of fields for this index. If set to true, Atlas Search recursively indexes all dynamically indexable fields. If set to false, you must specify individual fields to index using mappings.fields."
+                ),
+            fields: z
+                .record(
+                    z.string().describe("The field name"),
+                    z
+                        .object({
+                            type: z
+                                .enum([
+                                    "autocomplete",
+                                    "boolean",
+                                    "date",
+                                    "document",
+                                    "embeddedDocuments",
+                                    "geo",
+                                    "knnVector",
+                                    "number",
+                                    "objectId",
+                                    "string",
+                                    "token",
+                                    "uuid",
+                                ])
+                                .describe("The field type"),
+                        })
+                        .passthrough()
+
+                        .describe(
+                            "The field index definition. It must contain the field type, as well as any additional options for that field type."
+                        )
+                )
+                .optional()
+                .describe("The field mapping definitions. If `dynamic` is set to false, this is required."),
+        }),
+    };
+
+    protected operationType: OperationType = "create";
+
+    protected async execute({
+        database,
+        collection,
+        name,
+        type,
+        analyzer,
+        mappings,
+    }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const provider = await this.ensureConnected();
+        const indexes = await provider.createSearchIndexes(database, collection, [
+            {
+                name,
+                type,
+                definition: {
+                    analyzer,
+                    mappings,
+                },
+            },
+        ]);
+
+        return {
+            content: [
+                {
+                    text: `Created the index "${indexes[0]}" on collection "${collection}" in database "${database}"`,
+                    type: "text",
+                },
+            ],
+        };
+    }
+}

src/tools/mongodb/delete/dropIndex.ts

@@ -0,0 +1,29 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { z } from "zod";
+
+export class DropIndexTool extends MongoDBToolBase {
+    protected name = "drop-index";
+    protected description = "Removes an index from a collection.";
+    protected argsShape = {
+        ...DbOperationArgs,
+        name: z.string().describe("The name of the index to drop"),
+    };
+    protected operationType: OperationType = "delete";
+
+    protected async execute({ database, collection, name }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const provider = await this.ensureConnected();
+        await provider.mongoClient.db(database).collection(collection).dropIndex(name);
+        await provider.dropSearchIndex(database, collection, name);
+
+        return {
+            content: [
+                {
+                    text: `Successfully dropped index "${name}" in  "${database}.${collection}"`,
+                    type: "text",
+                },
+            ],
+        };
+    }
+}

src/tools/mongodb/read/collectionIndexes.ts

@@ -11,19 +11,26 @@ export class CollectionIndexesTool extends MongoDBToolBase {
     protected async execute({ database, collection }: ToolArgs<typeof DbOperationArgs>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
         const indexes = await provider.getIndexes(database, collection);
+        const searchIndexes = await provider.getSearchIndexes(database, collection);
 
         return {
             content: [
                 {
                     text: `Found ${indexes.length} indexes in the collection "${collection}":`,
                     type: "text",
                 },
-                ...(indexes.map((indexDefinition) => {
+                ...indexes.map((indexDefinition) => {
                     return {
                         text: `Name "${indexDefinition.name}", definition: ${JSON.stringify(indexDefinition.key)}`,
                         type: "text",
-                    };
-                }) as { text: string; type: "text" }[]),
+                    } as const;
+                }),
+                ...searchIndexes.map((indexDefinition) => {
+                    return {
+                        text: `Search index name: "${indexDefinition.name}", status: ${indexDefinition.status}, definition: ${JSON.stringify(indexDefinition.latestDefinition)}`,
+                        type: "text",
+                    } as const;
+                }),
             ],
         };
     }

src/tools/mongodb/tools.ts

@@ -1,7 +1,7 @@
 // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
 // import { ConnectTool } from "./metadata/connect.js";
 import { ListCollectionsTool } from "./metadata/listCollections.js";
-import { CollectionIndexesTool } from "./read/collectionIndexes.js";
+import { CollectionIndexesTool as ListIndexesTool } from "./read/collectionIndexes.js";
 import { ListDatabasesTool } from "./metadata/listDatabases.js";
 import { CreateIndexTool } from "./create/createIndex.js";
 import { CollectionSchemaTool } from "./metadata/collectionSchema.js";
@@ -19,27 +19,35 @@ import { DropCollectionTool } from "./delete/dropCollection.js";
 import { ExplainTool } from "./metadata/explain.js";
 import { CreateCollectionTool } from "./create/createCollection.js";
 import { LogsTool } from "./metadata/logs.js";
+import { CreateSearchIndexTool } from "./create/createSearchIndex.js";
+import { DropIndexTool } from "./delete/dropIndex.js";
 
 export const MongoDbTools = [
     // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
     // ConnectTool,
+    CreateCollectionTool,
     ListCollectionsTool,
-    ListDatabasesTool,
-    CollectionIndexesTool,
-    CreateIndexTool,
     CollectionSchemaTool,
-    FindTool,
-    InsertManyTool,
-    DeleteManyTool,
     CollectionStorageSizeTool,
-    CountTool,
-    DbStatsTool,
-    AggregateTool,
-    UpdateManyTool,
     RenameCollectionTool,
-    DropDatabaseTool,
     DropCollectionTool,
-    ExplainTool,
-    CreateCollectionTool,
+
+    ListDatabasesTool,
+    DropDatabaseTool,
+    DbStatsTool,
     LogsTool,
+
+    FindTool,
+    AggregateTool,
+    CountTool,
+    ExplainTool,
+
+    InsertManyTool,
+    DeleteManyTool,
+    UpdateManyTool,
+
+    CreateIndexTool,
+    CreateSearchIndexTool,
+    ListIndexesTool,
+    DropIndexTool,
 ];