chore: disable the connect tool

src/common/atlas/apiClient.ts

@@ -15,7 +15,7 @@ export interface ApiClientCredentials {
 
 export interface ApiClientOptions {
     credentials?: ApiClientCredentials;
-    baseUrl?: string;
+    baseUrl: string;
     userAgent?: string;
 }
 
@@ -63,12 +63,11 @@ export class ApiClient {
         },
     };
 
-    constructor(options?: ApiClientOptions) {
+    constructor(options: ApiClientOptions) {
         this.options = {
             ...options,
-            baseUrl: options?.baseUrl || "https://cloud.mongodb.com/",
             userAgent:
-                options?.userAgent ||
+                options.userAgent ||
                 `AtlasMCP/${packageInfo.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
         };
 

src/config.ts

@@ -7,7 +7,7 @@ import { ReadConcernLevel, ReadPreferenceMode, W } from "mongodb";
 // If we decide to support non-string config options, we'll need to extend the mechanism for parsing
 // env variables.
 export interface UserConfig {
-    apiBaseUrl?: string;
+    apiBaseUrl: string;
     apiClientId?: string;
     apiClientSecret?: string;
     telemetry?: "enabled" | "disabled";
@@ -24,6 +24,7 @@ export interface UserConfig {
 }
 
 const defaults: UserConfig = {
+    apiBaseUrl: "https://cloud.mongodb.com/",
     logPath: getLogPath(),
     connectOptions: {
         readConcern: "local",

src/index.ts

@@ -18,6 +18,7 @@ try {
         name: packageInfo.mcpServerName,
         version: packageInfo.version,
     });
+
     const server = new Server({
         mcpServer,
         session,

src/server.ts

@@ -11,6 +11,7 @@ import { type ServerEvent } from "./telemetry/types.js";
 import { type ServerCommand } from "./telemetry/types.js";
 import { CallToolRequestSchema, CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import assert from "assert";
+import { connectToMongoDB } from "./tools/mongodb/mongodbTool.js";
 
 export interface ServerOptions {
     session: Session;
@@ -33,7 +34,7 @@ export class Server {
         this.userConfig = userConfig;
     }
 
-    async connect(transport: Transport) {
+    async connect(transport: Transport): Promise<void> {
         this.mcpServer.server.registerCapabilities({ logging: {} });
 
         this.registerTools();
@@ -88,6 +89,8 @@ export class Server {
             const closeTime = Date.now();
             this.emitServerEvent("stop", Date.now() - closeTime, error);
         };
+
+        await this.validateConfig();
     }
 
     async close(): Promise<void> {
@@ -183,4 +186,29 @@ export class Server {
             );
         }
     }
+
+    private async validateConfig(): Promise<void> {
+        const isAtlasConfigured = this.userConfig.apiClientId && this.userConfig.apiClientSecret;
+        const isMongoDbConfigured = this.userConfig.connectionString;
+        if (!isAtlasConfigured && !isMongoDbConfigured) {
+            console.error(
+                "Either Atlas Client Id or a MongoDB connection string must be configured - you can provide them as environment variables or as startup arguments. \n" +
+                    "Provide the Atlas credentials as `MDB_MCP_API_CLIENT_ID` and `MDB_MCP_API_CLIENT_SECRET` environment variables or as `--apiClientId` and `--apiClientSecret` startup arguments. \n" +
+                    "Provide the MongoDB connection string as `MDB_MCP_CONNECTION_STRING` environment variable or as `--connectionString` startup argument."
+            );
+            throw new Error("Either Atlas Client Id or a MongoDB connection string must be configured");
+        }
+
+        if (this.userConfig.connectionString) {
+            try {
+                await connectToMongoDB(this.userConfig.connectionString, this.userConfig, this.session);
+            } catch (error) {
+                console.error(
+                    "Failed to connect to MongoDB instance using the connection string from the config: ",
+                    error
+                );
+                throw new Error("Failed to connect to MongoDB instance using the connection string from the config");
+            }
+        }
+    }
 }

src/session.ts

@@ -4,7 +4,7 @@ import { Implementation } from "@modelcontextprotocol/sdk/types.js";
 import EventEmitter from "events";
 
 export interface SessionOptions {
-    apiBaseUrl?: string;
+    apiBaseUrl: string;
     apiClientId?: string;
     apiClientSecret?: string;
 }
@@ -20,7 +20,7 @@ export class Session extends EventEmitter<{
         version: string;
     };
 
-    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions = {}) {
+    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions) {
         super();
 
         const credentials: ApiClientCredentials | undefined =

src/tools/mongodb/mongodbTool.ts

@@ -4,12 +4,31 @@ import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../errors.js";
 import logger, { LogId } from "../../logger.js";
+import { UserConfig } from "../../config.js";
+import { Session } from "../../session.js";
 
 export const DbOperationArgs = {
     database: z.string().describe("Database name"),
     collection: z.string().describe("Collection name"),
 };
 
+export async function connectToMongoDB(connectionString: string, config: UserConfig, session: Session): Promise<void> {
+    const provider = await NodeDriverServiceProvider.connect(connectionString, {
+        productDocsLink: "https://docs.mongodb.com/todo-mcp",
+        productName: "MongoDB MCP",
+        readConcern: {
+            level: config.connectOptions.readConcern,
+        },
+        readPreference: config.connectOptions.readPreference,
+        writeConcern: {
+            w: config.connectOptions.writeConcern,
+        },
+        timeoutMS: config.connectOptions.timeoutMS,
+    });
+
+    session.serviceProvider = provider;
+}
+
 export abstract class MongoDBToolBase extends ToolBase {
     protected category: ToolCategory = "mongodb";
 
@@ -70,20 +89,7 @@ export abstract class MongoDBToolBase extends ToolBase {
         return super.handleError(error, args);
     }
 
-    protected async connectToMongoDB(connectionString: string): Promise<void> {
-        const provider = await NodeDriverServiceProvider.connect(connectionString, {
-            productDocsLink: "https://docs.mongodb.com/todo-mcp",
-            productName: "MongoDB MCP",
-            readConcern: {
-                level: this.config.connectOptions.readConcern,
-            },
-            readPreference: this.config.connectOptions.readPreference,
-            writeConcern: {
-                w: this.config.connectOptions.writeConcern,
-            },
-            timeoutMS: this.config.connectOptions.timeoutMS,
-        });
-
-        this.session.serviceProvider = provider;
+    protected connectToMongoDB(connectionString: string): Promise<void> {
+        return connectToMongoDB(connectionString, this.config, this.session);
     }
 }

src/tools/mongodb/tools.ts

@@ -1,4 +1,5 @@
-import { ConnectTool } from "./metadata/connect.js";
+// 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 { ListDatabasesTool } from "./metadata/listDatabases.js";
@@ -20,7 +21,8 @@ import { CreateCollectionTool } from "./create/createCollection.js";
 import { LogsTool } from "./metadata/logs.js";
 
 export const MongoDbTools = [
-    ConnectTool,
+    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
+    // ConnectTool,
     ListCollectionsTool,
     ListDatabasesTool,
     CollectionIndexesTool,

tests/integration/helpers.ts

@@ -1,7 +1,7 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "./inMemoryTransport.js";
 import { Server } from "../../src/server.js";
 import { config, UserConfig } from "../../src/config.js";
 import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Session } from "../../src/session.js";
@@ -20,7 +20,7 @@
     mcpServer: () => Server;
 }
 
-export function setupIntegrationTest(getUserConfig: () => UserConfig = () => config): IntegrationTest {
+export function setupIntegrationTest(getUserConfig: () => UserConfig): IntegrationTest {
     let mcpClient: Client | undefined;
     let mcpServer: Server | undefined;
 

tests/integration/server.test.ts

@@ -1,14 +1,9 @@
 import { expectDefined, setupIntegrationTest } from "./helpers.js";
 import { config } from "../../src/config.js";
+import { describeWithMongoDB } from "./tools/mongodb/mongodbHelpers.js";
 
 describe("Server integration test", () => {
-    describe("without atlas", () => {
-        const integration = setupIntegrationTest(() => ({
-            ...config,
-            apiClientId: undefined,
-            apiClientSecret: undefined,
-        }));
-
+    describeWithMongoDB("without atlas", (integration) => {
         it("should return positive number of tools and have no atlas tools", async () => {
             const tools = await integration.mcpClient().listTools();
             expectDefined(tools);
@@ -18,6 +13,7 @@ describe("Server integration test", () => {
             expect(atlasTools.length).toBeLessThanOrEqual(0);
         });
     });
+
     describe("with atlas", () => {
         const integration = setupIntegrationTest(() => ({
             ...config,

tests/integration/tools/atlas/atlasHelpers.ts

@@ -2,6 +2,7 @@ import { ObjectId } from "mongodb";
 import { Group } from "../../../../src/common/atlas/openapi.js";
 import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
 import { setupIntegrationTest, IntegrationTest } from "../../helpers.js";
+import { config } from "../../../../src/config.js";
 
 export type IntegrationTestFunction = (integration: IntegrationTest) => void;
 
@@ -11,7 +12,12 @@ export function sleep(ms: number) {
 
 export function describeWithAtlas(name: string, fn: IntegrationTestFunction) {
     const testDefinition = () => {
-        const integration = setupIntegrationTest();
+        const integration = setupIntegrationTest(() => ({
+            ...config,
+            apiClientId: process.env.MDB_MCP_API_CLIENT_ID,
+            apiClientSecret: process.env.MDB_MCP_API_CLIENT_SECRET,
+        }));
+
         describe(name, () => {
             fn(integration);
         });

tests/integration/tools/mongodb/metadata/connect.test.ts

@@ -2,6 +2,8 @@ import { describeWithMongoDB } from "../mongodbHelpers.js";
 import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
 import { config } from "../../../../../src/config.js";
 
+// These tests are temporarily skipped because the connect tool is disabled for the initial release.
+// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
 describeWithMongoDB(
     "switchConnection tool",
     (integration) => {
@@ -75,50 +77,56 @@ describeWithMongoDB(
     (mdbIntegration) => ({
         ...config,
         connectionString: mdbIntegration.connectionString(),
-    })
+    }),
+    describe.skip
 );
-describeWithMongoDB("Connect tool", (integration) => {
-    validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
-        {
-            name: "connectionString",
-            description: "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
-            type: "string",
-            required: true,
-        },
-    ]);
+describeWithMongoDB(
+    "Connect tool",
+    (integration) => {
+        validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
+            {
+                name: "connectionString",
+                description: "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
+                type: "string",
+                required: true,
+            },
+        ]);
 
-    validateThrowsForInvalidArguments(integration, "connect", [{}, { connectionString: 123 }]);
+        validateThrowsForInvalidArguments(integration, "connect", [{}, { connectionString: 123 }]);
 
-    it("doesn't have the switch-connection tool registered", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const tool = tools.find((tool) => tool.name === "switch-connection");
-        expect(tool).toBeUndefined();
-    });
+        it("doesn't have the switch-connection tool registered", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const tool = tools.find((tool) => tool.name === "switch-connection");
+            expect(tool).toBeUndefined();
+        });
 
-    describe("with connection string", () => {
-        it("connects to the database", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "connect",
-                arguments: {
-                    connectionString: integration.connectionString(),
-                },
+        describe("with connection string", () => {
+            it("connects to the database", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: {
+                        connectionString: integration.connectionString(),
+                    },
+                });
+                const content = getResponseContent(response.content);
+                expect(content).toContain("Successfully connected");
             });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Successfully connected");
         });
-    });
 
-    describe("with invalid connection string", () => {
-        it("returns error message", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "connect",
-                arguments: { connectionString: "mongodb://localhost:12345" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Error running connect");
+        describe("with invalid connection string", () => {
+            it("returns error message", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: { connectionString: "mongodb://localhost:12345" },
+                });
+                const content = getResponseContent(response.content);
+                expect(content).toContain("Error running connect");
 
-            // Should not suggest using the config connection string (because we don't have one)
-            expect(content).not.toContain("Your config lists a different connection string");
+                // Should not suggest using the config connection string (because we don't have one)
+                expect(content).not.toContain("Your config lists a different connection string");
+            });
         });
-    });
-});
+    },
+    () => config,
+    describe.skip
+);