mongodb-mcp-server 0.0.5 → 0.0.7

package/src/index.ts

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import logger from "./logger.js";
-import { mongoLogId } from "mongodb-log-writer";
+import logger, { LogId } from "./logger.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { config } from "./config.js";
 import { Session } from "./session.js";
@@ -19,6 +18,7 @@ try {
         name: packageInfo.mcpServerName,
         version: packageInfo.version,
     });
+
     const server = new Server({
         mcpServer,
         session,
@@ -29,6 +29,6 @@ try {
 
     await server.connect(transport);
 } catch (error: unknown) {
-    logger.emergency(mongoLogId(1_000_004), "server", `Fatal error running server: ${error as string}`);
+    logger.emergency(LogId.serverStartFailure, "server", `Fatal error running server: ${error as string}`);
     process.exit(1);
 }

package/src/logger.ts

@@ -1,11 +1,31 @@
 import fs from "fs/promises";
-import { MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
+import { mongoLogId, MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
 import redact from "mongodb-redact";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
 
 export type LogLevel = LoggingMessageNotification["params"]["level"];
 
+export const LogId = {
+    serverStartFailure: mongoLogId(1_000_001),
+    serverInitialized: mongoLogId(1_000_002),
+
+    atlasCheckCredentials: mongoLogId(1_001_001),
+    atlasDeleteDatabaseUserFailure: mongoLogId(1_001_002),
+
+    telemetryDisabled: mongoLogId(1_002_001),
+    telemetryEmitFailure: mongoLogId(1_002_002),
+    telemetryEmitStart: mongoLogId(1_002_003),
+    telemetryEmitSuccess: mongoLogId(1_002_004),
+
+    toolExecute: mongoLogId(1_003_001),
+    toolExecuteFailure: mongoLogId(1_003_002),
+    toolDisabled: mongoLogId(1_003_003),
+
+    mongodbConnectFailure: mongoLogId(1_004_001),
+    mongodbDisconnectFailure: mongoLogId(1_004_002),
+} as const;
+
 abstract class LoggerBase {
     abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
 
@@ -106,6 +126,11 @@ class McpLogger extends LoggerBase {
     }
 
     log(level: LogLevel, _: MongoLogId, context: string, message: string): void {
+        // Only log if the server is connected
+        if (!this.server?.isConnected()) {
+            return;
+        }
+
         void this.server.server.sendLoggingMessage({
             level,
             data: `[${context}]: ${message}`,

package/src/server.ts

@@ -3,8 +3,7 @@ import { Session } from "./session.js";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { AtlasTools } from "./tools/atlas/tools.js";
 import { MongoDbTools } from "./tools/mongodb/tools.js";
-import logger, { initializeLogger } from "./logger.js";
-import { mongoLogId } from "mongodb-log-writer";
+import logger, { initializeLogger, LogId } from "./logger.js";
 import { ObjectId } from "mongodb";
 import { Telemetry } from "./telemetry/telemetry.js";
 import { UserConfig } from "./config.js";
@@ -23,7 +22,7 @@ export class Server {
     public readonly session: Session;
     private readonly mcpServer: McpServer;
     private readonly telemetry: Telemetry;
-    private readonly userConfig: UserConfig;
+    public readonly userConfig: UserConfig;
     private readonly startTime: number;
 
     constructor({ session, mcpServer, userConfig }: ServerOptions) {
@@ -34,8 +33,9 @@ export class Server {
         this.userConfig = userConfig;
     }
 
-    async connect(transport: Transport) {
+    async connect(transport: Transport): Promise<void> {
         this.mcpServer.server.registerCapabilities({ logging: {} });
+
         this.registerTools();
         this.registerResources();
 
@@ -71,7 +71,7 @@ export class Server {
             this.session.sessionId = new ObjectId().toString();
 
             logger.info(
-                mongoLogId(1_000_004),
+                LogId.serverInitialized,
                 "server",
                 `Server started with transport ${transport.constructor.name} and agent runner ${this.session.agentRunner?.name}`
             );
@@ -88,6 +88,8 @@ export class Server {
             const closeTime = Date.now();
             this.emitServerEvent("stop", Date.now() - closeTime, error);
         };
+
+        await this.validateConfig();
     }
 
     async close(): Promise<void> {
@@ -116,6 +118,8 @@ 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 || [];
         }
         if (command === "stop") {
             event.properties.runtime_duration_ms = Date.now() - this.startTime;
@@ -135,6 +139,32 @@ export class Server {
     }
 
     private registerResources() {
+        this.mcpServer.resource(
+            "config",
+            "config://config",
+            {
+                description:
+                    "Server configuration, supplied by the user either as environment variables or as startup arguments",
+            },
+            (uri) => {
+                const result = {
+                    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",
+                    connectOptions: this.userConfig.connectOptions,
+                };
+                return {
+                    contents: [
+                        {
+                            text: JSON.stringify(result),
+                            uri: uri.href,
+                        },
+                    ],
+                };
+            }
+        );
         if (this.userConfig.connectionString) {
             this.mcpServer.resource(
                 "connection-string",
@@ -155,4 +185,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 this.session.connectToMongoDB(this.userConfig.connectionString, this.userConfig.connectOptions);
+            } 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");
+            }
+        }
+    }
 }

package/src/session.ts

@@ -1,14 +1,20 @@
 import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import { ApiClient, ApiClientCredentials } from "./common/atlas/apiClient.js";
 import { Implementation } from "@modelcontextprotocol/sdk/types.js";
+import logger, { LogId } from "./logger.js";
+import EventEmitter from "events";
+import { ConnectOptions } from "./config.js";
 
 export interface SessionOptions {
-    apiBaseUrl?: string;
+    apiBaseUrl: string;
     apiClientId?: string;
     apiClientSecret?: string;
 }
 
-export class Session {
+export class Session extends EventEmitter<{
+    close: [];
+    disconnect: [];
+}> {
     sessionId?: string;
     serviceProvider?: NodeDriverServiceProvider;
     apiClient: ApiClient;
@@ -16,8 +22,16 @@ export class Session {
         name: string;
         version: string;
     };
+    connectedAtlasCluster?: {
+        username: string;
+        projectId: string;
+        clusterName: string;
+        expiryDate: Date;
+    };
+
+    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions) {
+        super();
 
-    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions = {}) {
         const credentials: ApiClientCredentials | undefined =
             apiClientId && apiClientSecret
                 ? {
@@ -41,14 +55,63 @@ export class Session {
         }
     }
 
-    async close(): Promise<void> {
+    async disconnect(): Promise<void> {
         if (this.serviceProvider) {
             try {
                 await this.serviceProvider.close(true);
-            } catch (error) {
-                console.error("Error closing service provider:", error);
+            } catch (err: unknown) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                logger.error(LogId.mongodbDisconnectFailure, "Error closing service provider:", error.message);
             }
             this.serviceProvider = undefined;
         }
+        if (!this.connectedAtlasCluster) {
+            this.emit("disconnect");
+            return;
+        }
+        try {
+            await this.apiClient.deleteDatabaseUser({
+                params: {
+                    path: {
+                        groupId: this.connectedAtlasCluster.projectId,
+                        username: this.connectedAtlasCluster.username,
+                        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}`
+            );
+        }
+        this.connectedAtlasCluster = undefined;
+
+        this.emit("disconnect");
+    }
+
+    async close(): Promise<void> {
+        await this.disconnect();
+        this.emit("close");
+    }
+
+    async connectToMongoDB(connectionString: string, connectOptions: ConnectOptions): Promise<void> {
+        const provider = await NodeDriverServiceProvider.connect(connectionString, {
+            productDocsLink: "https://docs.mongodb.com/todo-mcp",
+            productName: "MongoDB MCP",
+            readConcern: {
+                level: connectOptions.readConcern,
+            },
+            readPreference: connectOptions.readPreference,
+            writeConcern: {
+                w: connectOptions.writeConcern,
+            },
+            timeoutMS: connectOptions.timeoutMS,
+        });
+
+        this.serviceProvider = provider;
     }
 }

package/src/telemetry/constants.ts

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

package/src/telemetry/telemetry.ts

@@ -1,8 +1,7 @@
 import { Session } from "../session.js";
-import { BaseEvent } from "./types.js";
+import { BaseEvent, CommonProperties } from "./types.js";
 import { config } from "../config.js";
-import logger from "../logger.js";
-import { mongoLogId } from "mongodb-log-writer";
+import logger, { LogId } from "../logger.js";
 import { ApiClient } from "../common/atlas/apiClient.js";
 import { MACHINE_METADATA } from "./constants.js";
 import { EventCache } from "./eventCache.js";
@@ -12,19 +11,6 @@ type EventResult = {
     error?: Error;
 };
 
-type CommonProperties = {
-    device_id?: string;
-    mcp_server_version: string;
-    mcp_server_name: string;
-    mcp_client_version?: string;
-    mcp_client_name?: string;
-    platform: string;
-    arch: string;
-    os_type: string;
-    os_version?: string;
-    session_id?: string;
-};
-
 export class Telemetry {
     private readonly commonProperties: CommonProperties;
 
@@ -74,7 +60,7 @@ export class Telemetry {
 
             await this.emit(events);
         } catch {
-            logger.debug(mongoLogId(1_000_002), "telemetry", `Error emitting telemetry events.`);
+            logger.debug(LogId.telemetryEmitFailure, "telemetry", `Error emitting telemetry events.`);
         }
     }
 
@@ -88,6 +74,8 @@ export class Telemetry {
             mcp_client_version: this.session.agentRunner?.version,
             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",
         };
     }
 
@@ -100,7 +88,7 @@ export class Telemetry {
         const allEvents = [...cachedEvents, ...events];
 
         logger.debug(
-            mongoLogId(1_000_003),
+            LogId.telemetryEmitStart,
             "telemetry",
             `Attempting to send ${allEvents.length} events (${cachedEvents.length} cached)`
         );
@@ -108,12 +96,12 @@ export class Telemetry {
         const result = await this.sendEvents(this.session.apiClient, allEvents);
         if (result.success) {
             this.eventCache.clearEvents();
-            logger.debug(mongoLogId(1_000_004), "telemetry", `Sent ${allEvents.length} events successfully`);
+            logger.debug(LogId.telemetryEmitSuccess, "telemetry", `Sent ${allEvents.length} events successfully`);
             return;
         }
 
-        logger.warning(
-            mongoLogId(1_000_005),
+        logger.debug(
+            LogId.telemetryEmitFailure,
             "telemetry",
             `Error sending event to client: ${result.error instanceof Error ? result.error.message : String(result.error)}`
         );

package/src/telemetry/types.ts

@@ -3,6 +3,7 @@
  */
 export type TelemetryResult = "success" | "failure";
 export type ServerCommand = "start" | "stop";
+export type TelemetryBoolSet = "true" | "false";
 
 /**
  * Base interface for all events
@@ -14,21 +15,11 @@ export interface Event {
 }
 
 export interface BaseEvent extends Event {
-    properties: {
-        device_id?: string;
-        mcp_server_version: string;
-        mcp_server_name: string;
-        mcp_client_version?: string;
-        mcp_client_name?: string;
-        platform: string;
-        arch: string;
-        os_type: string;
+    properties: CommonProperties & {
         component: string;
         duration_ms: number;
         result: TelemetryResult;
         category: string;
-        os_version?: string;
-        session_id?: string;
     } & Event["properties"];
 }
 
@@ -56,5 +47,31 @@ export interface ServerEvent extends BaseEvent {
         reason?: string;
         startup_time_ms?: number;
         runtime_duration_ms?: number;
+        read_only_mode?: boolean;
+        disabled_tools?: string[];
     } & BaseEvent["properties"];
 }
+
+/**
+ * Interface for static properties, they can be fetched once and reused.
+ */
+export type CommonStaticProperties = {
+    device_id?: string;
+    mcp_server_version: string;
+    mcp_server_name: string;
+    platform: string;
+    arch: string;
+    os_type: string;
+    os_version?: string;
+};
+
+/**
+ * Common properties for all events that might change.
+ */
+export type CommonProperties = {
+    mcp_client_version?: string;
+    mcp_client_name?: string;
+    config_atlas_auth?: TelemetryBoolSet;
+    config_connection_string?: TelemetryBoolSet;
+    session_id?: string;
+} & CommonStaticProperties;

package/src/tools/atlas/{createAccessList.ts → create/createAccessList.ts}

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
 
 const DEFAULT_COMMENT = "Added by Atlas MCP";
 

package/src/tools/atlas/{createDBUser.ts → create/createDBUser.ts}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
-import { CloudDatabaseUser, DatabaseUserRole } from "../../common/atlas/openapi.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { CloudDatabaseUser, DatabaseUserRole } from "../../../common/atlas/openapi.js";
 
 export class CreateDBUserTool extends AtlasToolBase {
     protected name = "atlas-create-db-user";

package/src/tools/atlas/{createFreeCluster.ts → create/createFreeCluster.ts}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
-import { ClusterDescription20240805 } from "../../common/atlas/openapi.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { ClusterDescription20240805 } from "../../../common/atlas/openapi.js";
 
 export class CreateFreeClusterTool extends AtlasToolBase {
     protected name = "atlas-create-free-cluster";
@@ -47,7 +47,10 @@ export class CreateFreeClusterTool extends AtlasToolBase {
         });
 
         return {
-            content: [{ type: "text", text: `Cluster "${name}" has been created in region "${region}".` }],
+            content: [
+                { type: "text", text: `Cluster "${name}" has been created in region "${region}".` },
+                { type: "text", text: `Double check your access lists to enable your current IP.` },
+            ],
         };
     }
 }

package/src/tools/atlas/{createProject.ts → create/createProject.ts}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
-import { Group } from "../../common/atlas/openapi.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { Group } from "../../../common/atlas/openapi.js";
 
 export class CreateProjectTool extends AtlasToolBase {
     protected name = "atlas-create-project";

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

@@ -0,0 +1,114 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { randomBytes } from "crypto";
+import { promisify } from "util";
+
+const EXPIRY_MS = 1000 * 60 * 60 * 12; // 12 hours
+
+const randomBytesAsync = promisify(randomBytes);
+
+async function generateSecurePassword(): Promise<string> {
+    const buf = await randomBytesAsync(16);
+    const pass = buf.toString("base64url");
+    return pass;
+}
+
+export class ConnectClusterTool extends AtlasToolBase {
+    protected name = "atlas-connect-cluster";
+    protected description = "Connect to MongoDB Atlas cluster";
+    protected operationType: OperationType = "metadata";
+    protected argsShape = {
+        projectId: z.string().describe("Atlas project ID"),
+        clusterName: z.string().describe("Atlas cluster name"),
+    };
+
+    protected async execute({ projectId, clusterName }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        await this.session.disconnect();
+
+        const cluster = await this.session.apiClient.getCluster({
+            params: {
+                path: {
+                    groupId: projectId,
+                    clusterName,
+                },
+            },
+        });
+
+        if (!cluster) {
+            throw new Error("Cluster not found");
+        }
+
+        const baseConnectionString = cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard;
+
+        if (!baseConnectionString) {
+            throw new Error("Connection string not available");
+        }
+
+        const username = `mcpUser${Math.floor(Math.random() * 100000)}`;
+        const password = await generateSecurePassword();
+
+        const expiryDate = new Date(Date.now() + EXPIRY_MS);
+
+        const readOnly =
+            this.config.readOnly ||
+            (this.config.disabledTools?.includes("create") &&
+                this.config.disabledTools?.includes("update") &&
+                this.config.disabledTools?.includes("delete") &&
+                !this.config.disabledTools?.includes("read") &&
+                !this.config.disabledTools?.includes("metadata"));
+
+        const roleName = readOnly ? "readAnyDatabase" : "readWriteAnyDatabase";
+
+        await this.session.apiClient.createDatabaseUser({
+            params: {
+                path: {
+                    groupId: projectId,
+                },
+            },
+            body: {
+                databaseName: "admin",
+                groupId: projectId,
+                roles: [
+                    {
+                        roleName,
+                        databaseName: "admin",
+                    },
+                ],
+                scopes: [{ type: "CLUSTER", name: clusterName }],
+                username,
+                password,
+                awsIAMType: "NONE",
+                ldapAuthType: "NONE",
+                oidcAuthType: "NONE",
+                x509Type: "NONE",
+                deleteAfterDate: expiryDate.toISOString(),
+            },
+        });
+
+        this.session.connectedAtlasCluster = {
+            username,
+            projectId,
+            clusterName,
+            expiryDate,
+        };
+
+        const cn = new URL(baseConnectionString);
+        cn.username = username;
+        cn.password = password;
+        cn.searchParams.set("authSource", "admin");
+        const connectionString = cn.toString();
+
+        await this.session.connectToMongoDB(connectionString, this.config.connectOptions);
+
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Connected to cluster "${clusterName}"`,
+                },
+            ],
+        };
+    }
+}

package/src/tools/atlas/{inspectAccessList.ts → read/inspectAccessList.ts}

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
 
 export class InspectAccessListTool extends AtlasToolBase {
     protected name = "atlas-inspect-access-list";

package/src/tools/atlas/{inspectCluster.ts → read/inspectCluster.ts}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
-import { ClusterDescription20240805 } from "../../common/atlas/openapi.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { ClusterDescription20240805 } from "../../../common/atlas/openapi.js";
 
 export class InspectClusterTool extends AtlasToolBase {
     protected name = "atlas-inspect-cluster";

package/src/tools/atlas/{listClusters.ts → read/listClusters.ts}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
-import { PaginatedClusterDescription20240805, PaginatedOrgGroupView, Group } from "../../common/atlas/openapi.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { PaginatedClusterDescription20240805, PaginatedOrgGroupView, Group } from "../../../common/atlas/openapi.js";
 
 export class ListClustersTool extends AtlasToolBase {
     protected name = "atlas-list-clusters";

package/src/tools/atlas/{listDBUsers.ts → read/listDBUsers.ts}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "./atlasTool.js";
-import { ToolArgs, OperationType } from "../tool.js";
-import { DatabaseUserRole, UserScope } from "../../common/atlas/openapi.js";
+import { AtlasToolBase } from "../atlasTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { DatabaseUserRole, UserScope } from "../../../common/atlas/openapi.js";
 
 export class ListDBUsersTool extends AtlasToolBase {
     protected name = "atlas-list-db-users";