add vector search detection and a more graceful error message

nirinchev · nirinchev · commit e62725874ca1 · 2025-10-14T15:50:05.000+02:00
diff --git a/src/common/connectionManager.ts b/src/common/connectionManager.ts
@@ -32,9 +32,33 @@ export interface ConnectionState {
     connectedAtlasCluster?: AtlasClusterConnectionInfo;
 }
 
-export interface ConnectionStateConnected extends ConnectionState {
-    tag: "connected";
-    serviceProvider: NodeDriverServiceProvider;
+export class ConnectionStateConnected implements ConnectionState {
+    public tag = "connected" as const;
+
+    constructor(
+        public serviceProvider: NodeDriverServiceProvider,
+        public connectionStringAuthType?: ConnectionStringAuthType,
+        public connectedAtlasCluster?: AtlasClusterConnectionInfo
+    ) {}
+
+    private _isSearchSupported?: boolean;
+
+    public async isSearchSupported(): Promise<boolean> {
+        if (this._isSearchSupported === undefined) {
+            try {
+                const dummyDatabase = `search-index-test-db-${Date.now()}`;
+                const dummyCollection = `search-index-test-coll-${Date.now()}`;
+                // If a cluster supports search indexes, the call below will succeed
+                // with a cursor otherwise will throw an Error
+                await this.serviceProvider.getSearchIndexes(dummyDatabase, dummyCollection);
+                this._isSearchSupported = true;
+            } catch {
+                this._isSearchSupported = false;
+            }
+        }
+
+        return this._isSearchSupported;
+    }
 }
 
 export interface ConnectionStateConnecting extends ConnectionState {
@@ -199,12 +223,10 @@ export class MCPConnectionManager extends ConnectionManager {
                 });
             }
 
-            return this.changeState("connection-success", {
-                tag: "connected",
-                connectedAtlasCluster: settings.atlas,
-                serviceProvider: await serviceProvider,
-                connectionStringAuthType,
-            });
+            return this.changeState(
+                "connection-success",
+                new ConnectionStateConnected(await serviceProvider, connectionStringAuthType, settings.atlas)
+            );
         } catch (error: unknown) {
             const errorReason = error instanceof Error ? error.message : `${error as string}`;
             this.changeState("connection-error", {
@@ -270,11 +292,14 @@ export class MCPConnectionManager extends ConnectionManager {
             this.currentConnectionState.tag === "connecting" &&
             this.currentConnectionState.connectionStringAuthType?.startsWith("oidc")
         ) {
-            this.changeState("connection-success", {
-                ...this.currentConnectionState,
-                tag: "connected",
-                serviceProvider: await this.currentConnectionState.serviceProvider,
-            });
+            this.changeState(
+                "connection-success",
+                new ConnectionStateConnected(
+                    await this.currentConnectionState.serviceProvider,
+                    this.currentConnectionState.connectionStringAuthType,
+                    this.currentConnectionState.connectedAtlasCluster
+                )
+            );
         }
 
         this.logger.info({
diff --git a/src/common/session.ts b/src/common/session.ts
@@ -141,6 +141,15 @@ export class Session extends EventEmitter<SessionEvents> {
         return this.connectionManager.currentConnectionState.tag === "connected";
     }
 
+    get isConnectedToMongot(): Promise<boolean> {
+        const state = this.connectionManager.currentConnectionState;
+        if (state.tag === "connected") {
+            return state.isSearchSupported();
+        }
+
+        return Promise.resolve(false);
+    }
+
     get serviceProvider(): NodeDriverServiceProvider {
         if (this.isConnectedToMongoDB) {
             const state = this.connectionManager.currentConnectionState as ConnectionStateConnected;
@@ -153,17 +162,4 @@ export class Session extends EventEmitter<SessionEvents> {
     get connectedAtlasCluster(): AtlasClusterConnectionInfo | undefined {
         return this.connectionManager.currentConnectionState.connectedAtlasCluster;
     }
-
-    async isSearchIndexSupported(): Promise<boolean> {
-        try {
-            const dummyDatabase = `search-index-test-db-${Date.now()}`;
-            const dummyCollection = `search-index-test-coll-${Date.now()}`;
-            // If a cluster supports search indexes, the call below will succeed
-            // with a cursor otherwise will throw an Error
-            await this.serviceProvider.getSearchIndexes(dummyDatabase, dummyCollection);
-            return true;
-        } catch {
-            return false;
-        }
-    }
 }
diff --git a/src/resources/common/debug.ts b/src/resources/common/debug.ts
@@ -61,7 +61,7 @@ export class DebugResource extends ReactiveResource<
 
         switch (this.current.tag) {
             case "connected": {
-                const searchIndexesSupported = await this.session.isSearchIndexSupported();
+                const searchIndexesSupported = await this.session.isConnectedToMongot;
                 result += `The user is connected to the MongoDB cluster${searchIndexesSupported ? " with support for search indexes" : " without any support for search indexes"}.`;
                 break;
             }
diff --git a/src/tools/mongodb/create/createIndex.ts b/src/tools/mongodb/create/createIndex.ts
@@ -1,6 +1,7 @@
 import { z } from "zod";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
+import type { ToolCategory } from "../../tool.js";
 import { type ToolArgs, type OperationType, FeatureFlags } from "../../tool.js";
 import type { IndexDirection } from "mongodb";
 
@@ -108,15 +109,36 @@ export class CreateIndexTool extends MongoDBToolBase {
                 ]);
                 break;
             case "vectorSearch":
-                indexes = await provider.createSearchIndexes(database, collection, [
-                    {
-                        name,
-                        definition: {
-                            fields: definition.fields,
+                {
+                    const isVectorSearchSupported = await this.session.isConnectedToMongot;
+                    if (!isVectorSearchSupported) {
+                        // TODO: remove hacky casts once we merge the local dev tools
+                        const isLocalAtlasAvailable =
+                            (this.server?.tools.filter((t) => t.category === ("atlas-local" as unknown as ToolCategory))
+                                .length ?? 0) > 0;
+
+                        const CTA = isLocalAtlasAvailable ? "`atlas-local` tools" : "Atlas CLI";
+                        return {
+                            content: [
+                                {
+                                    text: `The connected MongoDB deployment does not support vector search indexes. Either connect to a MongoDB Atlas cluster or use the ${CTA} to create and manage a local Atlas deployment.`,
+                                    type: "text",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+
+                    indexes = await provider.createSearchIndexes(database, collection, [
+                        {
+                            name,
+                            definition: {
+                                fields: definition.fields,
+                            },
+                            type: "vectorSearch",
                         },
-                        type: "vectorSearch",
-                    },
-                ]);
+                    ]);
+                }
 
                 break;
         }
diff --git a/src/tools/mongodb/mongodbTool.ts b/src/tools/mongodb/mongodbTool.ts
@@ -13,7 +13,7 @@ export const DbOperationArgs = {
 };
 
 export abstract class MongoDBToolBase extends ToolBase {
-    private server?: Server;
+    protected server?: Server;
     public category: ToolCategory = "mongodb";
 
     protected async ensureConnected(): Promise<NodeDriverServiceProvider> {
diff --git a/tests/integration/tools/mongodb/create/createIndex.test.ts b/tests/integration/tools/mongodb/create/createIndex.test.ts
@@ -311,6 +311,36 @@ describeWithMongoDB(
             await validateIndex("coll1", [{ name: "prop1_1", key: { prop1: 1 } }]);
         });
 
+        it("fails to create a vector search index", async () => {
+            await integration.connectMcpClient();
+            const collection = new ObjectId().toString();
+            await integration
+                .mcpServer()
+                .session.serviceProvider.createCollection(integration.randomDbName(), collection);
+
+            const response = await integration.mcpClient().callTool({
+                name: "create-index",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection,
+                    name: "vector_1_vector",
+                    definition: [
+                        {
+                            type: "vectorSearch",
+                            fields: [
+                                { type: "vector", path: "vector_1", numDimensions: 4 },
+                                { type: "filter", path: "category" },
+                            ],
+                        },
+                    ],
+                },
+            });
+
+            const content = getResponseContent(response.content);
+            expect(content).toContain("The connected MongoDB deployment does not support vector search indexes.");
+            expect(response.isError).toBe(true);
+        });
+
         const testCases: { name: string; direction: IndexDirection }[] = [
             { name: "descending", direction: -1 },
             { name: "ascending", direction: 1 },

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ export class DebugResource extends ReactiveResource<`
`61`	`61`
`62`	`62`	`switch (this.current.tag) {`
`63`	`63`	`case "connected": {`
`64`		`- const searchIndexesSupported = await this.session.isSearchIndexSupported();`
	`64`	`+ const searchIndexesSupported = await this.session.isConnectedToMongot;`
`65`	`65`	result += `The user is connected to the MongoDB cluster${searchIndexesSupported ? " with support for search indexes" : " without any support for search indexes"}.`;
`66`	`66`	`break;`
`67`	`67`	`}`