mongodb-mcp-server 0.0.7 → 0.1.0

package/src/server.ts

@@ -28,7 +28,7 @@ export class Server {
     constructor({ session, mcpServer, userConfig }: ServerOptions) {
         this.startTime = Date.now();
         this.session = session;
-        this.telemetry = new Telemetry(session);
+        this.telemetry = new Telemetry(session, userConfig);
         this.mcpServer = mcpServer;
         this.userConfig = userConfig;
     }
@@ -107,7 +107,6 @@ export class Server {
             timestamp: new Date().toISOString(),
             source: "mdbmcp",
             properties: {
-                ...this.telemetry.getCommonProperties(),
                 result: "success",
                 duration_ms: commandDuration,
                 component: "server",
@@ -119,7 +118,7 @@ export class Server {
         if (command === "start") {
             event.properties.startup_time_ms = commandDuration;
             event.properties.read_only_mode = this.userConfig.readOnly || false;
-            event.properties.disallowed_tools = this.userConfig.disabledTools || [];
+            event.properties.disabled_tools = this.userConfig.disabledTools || [];
         }
         if (command === "stop") {
             event.properties.runtime_duration_ms = Date.now() - this.startTime;
@@ -151,39 +150,25 @@ export class Server {
                     telemetry: this.userConfig.telemetry,
                     logPath: this.userConfig.logPath,
                     connectionString: this.userConfig.connectionString
-                        ? "set; no explicit connect needed, use switch-connection tool to connect to a different connection if necessary"
-                        : "not set; before using any mongodb tool, you need to call the connect tool with a connection string",
+                        ? "set; access to MongoDB tools are currently available to use"
+                        : "not set; before using any MongoDB tool, you need to configure a connection string, alternatively you can setup MongoDB Atlas access, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",
                     connectOptions: this.userConfig.connectOptions,
+                    atlas:
+                        this.userConfig.apiClientId && this.userConfig.apiClientSecret
+                            ? "set; MongoDB Atlas tools are currently available to use"
+                            : "not set; MongoDB Atlas tools are currently unavailable, to have access to MongoDB Atlas tools like creating clusters or connecting to clusters make sure to setup credentials, more info at 'https://github.com/mongodb-js/mongodb-mcp-server'.",
                 };
                 return {
                     contents: [
                         {
                             text: JSON.stringify(result),
+                            mimeType: "application/json",
                             uri: uri.href,
                         },
                     ],
                 };
             }
         );
-        if (this.userConfig.connectionString) {
-            this.mcpServer.resource(
-                "connection-string",
-                "config://connection-string",
-                {
-                    description: "Preconfigured connection string that will be used as a default in the `connect` tool",
-                },
-                (uri) => {
-                    return {
-                        contents: [
-                            {
-                                text: `Preconfigured connection string: ${this.userConfig.connectionString}`,
-                                uri: uri.href,
-                            },
-                        ],
-                    };
-                }
-            );
-        }
     }
 
     private async validateConfig(): Promise<void> {

package/src/session.ts

@@ -69,8 +69,8 @@ export class Session extends EventEmitter<{
             this.emit("disconnect");
             return;
         }
-        try {
-            await this.apiClient.deleteDatabaseUser({
+        void this.apiClient
+            .deleteDatabaseUser({
                 params: {
                     path: {
                         groupId: this.connectedAtlasCluster.projectId,
@@ -78,16 +78,15 @@ export class Session extends EventEmitter<{
                         databaseName: "admin",
                     },
                 },
+            })
+            .catch((err: unknown) => {
+                const error = err instanceof Error ? err : new Error(String(err));
+                logger.error(
+                    LogId.atlasDeleteDatabaseUserFailure,
+                    "atlas-connect-cluster",
+                    `Error deleting previous database user: ${error.message}`
+                );
             });
-        } catch (err: unknown) {
-            const error = err instanceof Error ? err : new Error(String(err));
-
-            logger.error(
-                LogId.atlasDeleteDatabaseUserFailure,
-                "atlas-connect-cluster",
-                `Error deleting previous database user: ${error.message}`
-            );
-        }
         this.connectedAtlasCluster = undefined;
 
         this.emit("disconnect");

package/src/telemetry/constants.ts

@@ -1,11 +1,11 @@
-import { getMachineIdSync } from "native-machine-id";
 import { packageInfo } from "../packageInfo.js";
 import { type CommonStaticProperties } from "./types.js";
+import { getDeviceId } from "./device-id.js";
 /**
  * Machine-specific metadata formatted for telemetry
  */
 export const MACHINE_METADATA: CommonStaticProperties = {
-    device_id: getMachineIdSync(),
+    device_id: getDeviceId(),
     mcp_server_version: packageInfo.version,
     mcp_server_name: packageInfo.mcpServerName,
     platform: process.platform,

package/src/telemetry/device-id.ts

@@ -0,0 +1,21 @@
+import { createHmac } from "crypto";
+import nodeMachineId from "node-machine-id";
+import logger, { LogId } from "../logger.js";
+
+export function getDeviceId(): string {
+    try {
+        const originalId = nodeMachineId.machineIdSync(true);
+        // Create a hashed format from the all uppercase version of the machine ID
+        // to match it exactly with the denisbrodbeck/machineid library that Atlas CLI uses.
+        const hmac = createHmac("sha256", originalId.toUpperCase());
+
+        /** This matches the message used to create the hashes in Atlas CLI */
+        const DEVICE_ID_HASH_MESSAGE = "atlascli";
+
+        hmac.update(DEVICE_ID_HASH_MESSAGE);
+        return hmac.digest("hex");
+    } catch (error) {
+        logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
+        return "unknown";
+    }
+}

package/src/telemetry/eventCache.ts

@@ -13,7 +13,7 @@ export class EventCache {
     private cache: LRUCache<number, BaseEvent>;
     private nextId = 0;
 
-    private constructor() {
+    constructor() {
         this.cache = new LRUCache({
             max: EventCache.MAX_EVENTS,
             // Using FIFO eviction strategy for events

package/src/telemetry/telemetry.ts

@@ -1,6 +1,6 @@
 import { Session } from "../session.js";
 import { BaseEvent, CommonProperties } from "./types.js";
-import { config } from "../config.js";
+import { UserConfig } from "../config.js";
 import logger, { LogId } from "../logger.js";
 import { ApiClient } from "../common/atlas/apiClient.js";
 import { MACHINE_METADATA } from "./constants.js";
@@ -16,6 +16,7 @@ export class Telemetry {
 
     constructor(
         private readonly session: Session,
+        private readonly userConfig: UserConfig,
         private readonly eventCache: EventCache = EventCache.getInstance()
     ) {
         this.commonProperties = {
@@ -23,38 +24,14 @@ export class Telemetry {
         };
     }
 
-    /**
-     * Checks if telemetry is currently enabled
-     * This is a method rather than a constant to capture runtime config changes
-     *
-     * Follows the Console Do Not Track standard (https://consoledonottrack.com/)
-     * by respecting the DO_NOT_TRACK environment variable
-     */
-    private static isTelemetryEnabled(): boolean {
-        // Check if telemetry is explicitly disabled in config
-        if (config.telemetry === "disabled") {
-            return false;
-        }
-
-        const doNotTrack = process.env.DO_NOT_TRACK;
-        if (doNotTrack) {
-            const value = doNotTrack.toLowerCase();
-            // Telemetry should be disabled if DO_NOT_TRACK is "1", "true", or "yes"
-            if (value === "1" || value === "true" || value === "yes") {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
     /**
      * Emits events through the telemetry pipeline
      * @param events - The events to emit
      */
     public async emitEvents(events: BaseEvent[]): Promise<void> {
         try {
-            if (!Telemetry.isTelemetryEnabled()) {
+            if (!this.isTelemetryEnabled()) {
+                logger.info(LogId.telemetryEmitFailure, "telemetry", `Telemetry is disabled.`);
                 return;
             }
 
@@ -75,10 +52,27 @@ export class Telemetry {
             mcp_client_name: this.session.agentRunner?.name,
             session_id: this.session.sessionId,
             config_atlas_auth: this.session.apiClient.hasCredentials() ? "true" : "false",
-            config_connection_string: config.connectionString ? "true" : "false",
+            config_connection_string: this.userConfig.connectionString ? "true" : "false",
         };
     }
 
+    /**
+     * Checks if telemetry is currently enabled
+     * This is a method rather than a constant to capture runtime config changes
+     *
+     * Follows the Console Do Not Track standard (https://consoledonottrack.com/)
+     * by respecting the DO_NOT_TRACK environment variable
+     */
+    public isTelemetryEnabled(): boolean {
+        // Check if telemetry is explicitly disabled in config
+        if (this.userConfig.telemetry === "disabled") {
+            return false;
+        }
+
+        const doNotTrack = "DO_NOT_TRACK" in process.env;
+        return !doNotTrack;
+    }
+
     /**
      * Attempts to emit events through authenticated and unauthenticated clients
      * Falls back to caching if both attempts fail
@@ -96,7 +90,11 @@ export class Telemetry {
         const result = await this.sendEvents(this.session.apiClient, allEvents);
         if (result.success) {
             this.eventCache.clearEvents();
-            logger.debug(LogId.telemetryEmitSuccess, "telemetry", `Sent ${allEvents.length} events successfully`);
+            logger.debug(
+                LogId.telemetryEmitSuccess,
+                "telemetry",
+                `Sent ${allEvents.length} events successfully: ${JSON.stringify(allEvents, null, 2)}`
+            );
             return;
         }
 
@@ -113,7 +111,12 @@ export class Telemetry {
      */
     private async sendEvents(client: ApiClient, events: BaseEvent[]): Promise<EventResult> {
         try {
-            await client.sendEvents(events);
+            await client.sendEvents(
+                events.map((event) => ({
+                    ...event,
+                    properties: { ...this.getCommonProperties(), ...event.properties },
+                }))
+            );
             return { success: true };
         } catch (error) {
             return {

package/src/telemetry/types.ts

@@ -8,49 +8,46 @@ export type TelemetryBoolSet = "true" | "false";
 /**
  * Base interface for all events
  */
-export interface Event {
+export type TelemetryEvent<T> = {
     timestamp: string;
     source: "mdbmcp";
-    properties: Record<string, unknown>;
-}
-
-export interface BaseEvent extends Event {
-    properties: CommonProperties & {
+    properties: T & {
         component: string;
         duration_ms: number;
         result: TelemetryResult;
         category: string;
-    } & Event["properties"];
-}
+    };
+};
+
+export type BaseEvent = TelemetryEvent<unknown>;
 
 /**
  * Interface for tool events
  */
-export interface ToolEvent extends BaseEvent {
-    properties: {
-        command: string;
-        error_code?: string;
-        error_type?: string;
-        project_id?: string;
-        org_id?: string;
-        cluster_name?: string;
-        is_atlas?: boolean;
-    } & BaseEvent["properties"];
-}
+export type ToolEventProperties = {
+    command: string;
+    error_code?: string;
+    error_type?: string;
+    project_id?: string;
+    org_id?: string;
+    cluster_name?: string;
+    is_atlas?: boolean;
+};
 
+export type ToolEvent = TelemetryEvent<ToolEventProperties>;
 /**
  * Interface for server events
  */
-export interface ServerEvent extends BaseEvent {
-    properties: {
-        command: ServerCommand;
-        reason?: string;
-        startup_time_ms?: number;
-        runtime_duration_ms?: number;
-        read_only_mode?: boolean;
-        disabled_tools?: string[];
-    } & BaseEvent["properties"];
-}
+export type ServerEventProperties = {
+    command: ServerCommand;
+    reason?: string;
+    startup_time_ms?: number;
+    runtime_duration_ms?: number;
+    read_only_mode?: boolean;
+    disabled_tools?: string[];
+};
+
+export type ServerEvent = TelemetryEvent<ServerEventProperties>;
 
 /**
  * Interface for static properties, they can be fetched once and reused.
@@ -69,6 +66,7 @@ export type CommonStaticProperties = {
  * Common properties for all events that might change.
  */
 export type CommonProperties = {
+    device_id?: string;
     mcp_client_version?: string;
     mcp_client_name?: string;
     config_atlas_auth?: TelemetryBoolSet;

package/src/tools/atlas/atlasTool.ts

@@ -1,4 +1,7 @@
-import { ToolBase, ToolCategory } from "../tool.js";
+import { ToolBase, ToolCategory, TelemetryToolMetadata } from "../tool.js";
+import { ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
+import logger, { LogId } from "../../logger.js";
+import { z } from "zod";
 
 export abstract class AtlasToolBase extends ToolBase {
     protected category: ToolCategory = "atlas";
@@ -9,4 +12,46 @@ export abstract class AtlasToolBase extends ToolBase {
         }
         return super.verifyAllowed();
     }
+
+    /**
+     *
+     * Resolves the tool metadata from the arguments passed to the tool
+     *
+     * @param args - The arguments passed to the tool
+     * @returns The tool metadata
+     */
+    protected resolveTelemetryMetadata(
+        ...args: Parameters<ToolCallback<typeof this.argsShape>>
+    ): TelemetryToolMetadata {
+        const toolMetadata: TelemetryToolMetadata = {};
+        if (!args.length) {
+            return toolMetadata;
+        }
+
+        // Create a typed parser for the exact shape we expect
+        const argsShape = z.object(this.argsShape);
+        const parsedResult = argsShape.safeParse(args[0]);
+
+        if (!parsedResult.success) {
+            logger.debug(
+                LogId.telemetryMetadataError,
+                "tool",
+                `Error parsing tool arguments: ${parsedResult.error.message}`
+            );
+            return toolMetadata;
+        }
+
+        const data = parsedResult.data;
+
+        // Extract projectId using type guard
+        if ("projectId" in data && typeof data.projectId === "string" && data.projectId.trim() !== "") {
+            toolMetadata.projectId = data.projectId;
+        }
+
+        // Extract orgId using type guard
+        if ("orgId" in data && typeof data.orgId === "string" && data.orgId.trim() !== "") {
+            toolMetadata.orgId = data.orgId;
+        }
+        return toolMetadata;
+    }
 }

package/src/tools/atlas/metadata/connectCluster.ts

@@ -4,6 +4,7 @@ import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { randomBytes } from "crypto";
 import { promisify } from "util";
+import logger, { LogId } from "../../../logger.js";
 
 const EXPIRY_MS = 1000 * 60 * 60 * 12; // 12 hours
 
@@ -15,6 +16,10 @@ async function generateSecurePassword(): Promise<string> {
     return pass;
 }
 
+function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 export class ConnectClusterTool extends AtlasToolBase {
     protected name = "atlas-connect-cluster";
     protected description = "Connect to MongoDB Atlas cluster";
@@ -100,7 +105,31 @@ export class ConnectClusterTool extends AtlasToolBase {
         cn.searchParams.set("authSource", "admin");
         const connectionString = cn.toString();
 
-        await this.session.connectToMongoDB(connectionString, this.config.connectOptions);
+        let lastError: Error | undefined = undefined;
+
+        for (let i = 0; i < 20; i++) {
+            try {
+                await this.session.connectToMongoDB(connectionString, this.config.connectOptions);
+                lastError = undefined;
+                break;
+            } catch (err: unknown) {
+                const error = err instanceof Error ? err : new Error(String(err));
+
+                lastError = error;
+
+                logger.debug(
+                    LogId.atlasConnectFailure,
+                    "atlas-connect-cluster",
+                    `error connecting to cluster: ${error.message}`
+                );
+
+                await sleep(500); // wait for 500ms before retrying
+            }
+        }
+
+        if (lastError) {
+            throw lastError;
+        }
 
         return {
             content: [

package/src/tools/atlas/read/inspectCluster.ts

@@ -31,13 +31,38 @@ export class InspectClusterTool extends AtlasToolBase {
             throw new Error("Cluster not found");
         }
 
+        const regionConfigs = (cluster.replicationSpecs || [])
+            .map(
+                (replicationSpec) =>
+                    (replicationSpec.regionConfigs || []) as {
+                        providerName: string;
+                        electableSpecs?: {
+                            instanceSize: string;
+                        };
+                        readOnlySpecs?: {
+                            instanceSize: string;
+                        };
+                    }[]
+            )
+            .flat()
+            .map((regionConfig) => {
+                return {
+                    providerName: regionConfig.providerName,
+                    instanceSize: regionConfig.electableSpecs?.instanceSize || regionConfig.readOnlySpecs?.instanceSize,
+                };
+            });
+
+        const instanceSize = (regionConfigs.length <= 0 ? undefined : regionConfigs[0].instanceSize) || "UNKNOWN";
+
+        const clusterInstanceType = instanceSize == "M0" ? "FREE" : "DEDICATED";
+
         return {
             content: [
                 {
                     type: "text",
-                    text: `Cluster Name | State | MongoDB Version | Connection String
-----------------|----------------|----------------|----------------|----------------
-${cluster.name} | ${cluster.stateName} | ${cluster.mongoDBVersion || "N/A"} | ${cluster.connectionStrings?.standard || "N/A"}`,
+                    text: `Cluster Name | Cluster Type | Tier | State | MongoDB Version | Connection String
+----------------|----------------|----------------|----------------|----------------|----------------
+${cluster.name} | ${clusterInstanceType} | ${clusterInstanceType == "DEDICATED" ? instanceSize : "N/A"} | ${cluster.stateName} | ${cluster.mongoDBVersion || "N/A"} | ${cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard || "N/A"}`,
                 },
             ],
         };

package/src/tools/atlas/read/listClusters.ts

@@ -79,9 +79,37 @@ ${rows}`,
         }
         const rows = clusters.results
             .map((cluster) => {
-                const connectionString = cluster.connectionStrings?.standard || "N/A";
+                const connectionString =
+                    cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard || "N/A";
                 const mongoDBVersion = cluster.mongoDBVersion || "N/A";
-                return `${cluster.name} | ${cluster.stateName} | ${mongoDBVersion} | ${connectionString}`;
+                const regionConfigs = (cluster.replicationSpecs || [])
+                    .map(
+                        (replicationSpec) =>
+                            (replicationSpec.regionConfigs || []) as {
+                                providerName: string;
+                                electableSpecs?: {
+                                    instanceSize: string;
+                                };
+                                readOnlySpecs?: {
+                                    instanceSize: string;
+                                };
+                            }[]
+                    )
+                    .flat()
+                    .map((regionConfig) => {
+                        return {
+                            providerName: regionConfig.providerName,
+                            instanceSize:
+                                regionConfig.electableSpecs?.instanceSize || regionConfig.readOnlySpecs?.instanceSize,
+                        };
+                    });
+
+                const instanceSize =
+                    (regionConfigs.length <= 0 ? undefined : regionConfigs[0].instanceSize) || "UNKNOWN";
+
+                const clusterInstanceType = instanceSize == "M0" ? "FREE" : "DEDICATED";
+
+                return `${cluster.name} | ${clusterInstanceType} | ${clusterInstanceType == "DEDICATED" ? instanceSize : "N/A"} | ${cluster.stateName} | ${mongoDBVersion} | ${connectionString}`;
             })
             .join("\n");
         return {
@@ -92,8 +120,8 @@ ${rows}`,
                 },
                 {
                     type: "text",
-                    text: `Cluster Name | State | MongoDB Version | Connection String
-----------------|----------------|----------------|----------------|----------------
+                    text: `Cluster Name | Cluster Type | Tier | State | MongoDB Version | Connection String
+----------------|----------------|----------------|----------------|----------------|----------------
 ${rows}`,
                 },
             ],

package/src/tools/mongodb/mongodbTool.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ToolArgs, ToolBase, ToolCategory } from "../tool.js";
+import { ToolArgs, ToolBase, ToolCategory, TelemetryToolMetadata } from "../tool.js";
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../errors.js";
@@ -73,4 +73,18 @@ export abstract class MongoDBToolBase extends ToolBase {
     protected connectToMongoDB(connectionString: string): Promise<void> {
         return this.session.connectToMongoDB(connectionString, this.config.connectOptions);
     }
+
+    protected resolveTelemetryMetadata(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        args: ToolArgs<typeof this.argsShape>
+    ): TelemetryToolMetadata {
+        const metadata: TelemetryToolMetadata = {};
+
+        // Add projectId to the metadata if running a MongoDB operation to an Atlas cluster
+        if (this.session.connectedAtlasCluster?.projectId) {
+            metadata.projectId = this.session.connectedAtlasCluster.projectId;
+        }
+
+        return metadata;
+    }
 }