mongodb-mcp-server 0.0.4 → 0.0.5

package/eslint.config.js

@@ -2,18 +2,34 @@ import { defineConfig, globalIgnores } from "eslint/config";
 import js from "@eslint/js";
 import globals from "globals";
 import tseslint from "typescript-eslint";
-import eslintConfigPrettier from "eslint-config-prettier/flat";
+import eslintPluginPrettierRecommended from "eslint-plugin-prettier/recommended";
+import jestPlugin from "eslint-plugin-jest";
 
-const files = ["src/**/*.ts", "scripts/**/*.ts", "tests/**/*.test.ts", "eslint.config.js", "jest.config.js"];
+const testFiles = ["tests/**/*.test.ts", "tests/**/*.ts"];
+
+const files = [...testFiles, "src/**/*.ts", "scripts/**/*.ts"];
 
 export default defineConfig([
     { files, plugins: { js }, extends: ["js/recommended"] },
     { files, languageOptions: { globals: globals.node } },
+    {
+        files: testFiles,
+        plugins: {
+            jest: jestPlugin,
+        },
+        languageOptions: {
+            globals: {
+                ...globals.node,
+                ...jestPlugin.environments.globals.globals,
+            },
+        },
+    },
     tseslint.configs.recommendedTypeChecked,
     {
+        files,
         languageOptions: {
             parserOptions: {
-                projectService: true,
+                project: "./tsconfig.lint.json",
                 tsconfigRootDir: import.meta.dirname,
             },
         },
@@ -25,11 +41,14 @@ export default defineConfig([
             "@typescript-eslint/no-non-null-assertion": "error",
         },
     },
-    // Ignore features specific to TypeScript resolved rules
-    tseslint.config({
-        // TODO: Configure tests and scripts to work with this.
-        ignores: ["eslint.config.js", "jest.config.js", "tests/**/*.ts", "scripts/**/*.ts"],
-    }),
-    globalIgnores(["node_modules", "dist", "src/common/atlas/openapi.d.ts", "coverage"]),
-    eslintConfigPrettier,
+    globalIgnores([
+        "node_modules",
+        "dist",
+        "src/common/atlas/openapi.d.ts",
+        "coverage",
+        "global.d.ts",
+        "eslint.config.js",
+        "jest.config.js",
+    ]),
+    eslintPluginPrettierRecommended,
 ]);

package/global.d.ts

@@ -0,0 +1 @@
+import "jest-extended";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mongodb-mcp-server",
   "description": "MongoDB Model Context Protocol Server",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "main": "dist/index.js",
   "author": "MongoDB <info@mongodb.com>",
   "homepage": "https://github.com/mongodb-js/mongodb-mcp-server",
@@ -41,12 +41,15 @@
     "@types/simple-oauth2": "^5.0.7",
     "@types/yargs-parser": "^21.0.3",
     "eslint": "^9.24.0",
-    "eslint-config-prettier": "^10.1.1",
+    "eslint-config-prettier": "^10.1.2",
+    "eslint-plugin-jest": "^28.11.0",
+    "eslint-plugin-prettier": "^5.2.6",
     "globals": "^16.0.0",
     "jest": "^29.7.0",
     "jest-environment-node": "^29.7.0",
     "jest-extended": "^4.0.2",
     "mongodb-runner": "^5.8.2",
+    "native-machine-id": "^0.1.0",
     "openapi-types": "^12.1.3",
     "openapi-typescript": "^7.6.1",
     "prettier": "^3.5.3",
@@ -61,6 +64,7 @@
     "@mongodb-js/devtools-connect": "^3.7.2",
     "@mongosh/service-provider-node-driver": "^3.6.0",
     "bson": "^6.10.3",
+    "lru-cache": "^11.1.0",
     "mongodb": "^6.15.0",
     "mongodb-log-writer": "^2.4.1",
     "mongodb-redact": "^1.1.6",

package/scripts/apply.ts

@@ -9,13 +9,15 @@ function findObjectFromRef<T>(obj: T | OpenAPIV3_1.ReferenceObject, openapi: Ope
     }
     const paramParts = ref.split("/");
     paramParts.shift(); // Remove the first part which is always '#'
-    let foundObj: any = openapi; // eslint-disable-line @typescript-eslint/no-explicit-any
+
+    let foundObj: Record<string, unknown> = openapi;
     while (true) {
         const part = paramParts.shift();
         if (!part) {
             break;
         }
-        foundObj = foundObj[part];
+
+        foundObj = foundObj[part] as Record<string, unknown>;
     }
     return foundObj as T;
 }
@@ -28,7 +30,7 @@ async function main() {
         process.exit(1);
     }
 
-    const specFile = (await fs.readFile(spec, "utf8")) as string;
+    const specFile = await fs.readFile(spec as string, "utf8");
 
     const operations: {
         path: string;
@@ -42,7 +44,7 @@ async function main() {
     const openapi = JSON.parse(specFile) as OpenAPIV3_1.Document;
     for (const path in openapi.paths) {
         for (const method in openapi.paths[path]) {
-            const operation: OpenAPIV3_1.OperationObject = openapi.paths[path][method];
+            const operation = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
 
             if (!operation.operationId || !operation.tags?.length) {
                 continue;
@@ -101,9 +103,9 @@ async function main() {
         })
         .join("\n");
 
-    const templateFile = (await fs.readFile(file, "utf8")) as string;
+    const templateFile = await fs.readFile(file as string, "utf8");
     const templateLines = templateFile.split("\n");
-    let outputLines: string[] = [];
+    const outputLines: string[] = [];
     let addLines = true;
     for (const line of templateLines) {
         if (line.includes("DO NOT EDIT. This is auto-generated code.")) {
@@ -120,7 +122,7 @@ async function main() {
     }
     const output = outputLines.join("\n");
 
-    await fs.writeFile(file, output, "utf8");
+    await fs.writeFile(file as string, output, "utf8");
 }
 
 main().catch((error) => {

package/scripts/filter.ts

@@ -8,6 +8,7 @@ async function readStdin() {
             reject(err);
         });
         process.stdin.on("data", (chunk) => {
+            // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
             data += chunk;
         });
         process.stdin.on("end", () => {
@@ -42,8 +43,8 @@ function filterOpenapi(openapi: OpenAPIV3_1.Document): OpenAPIV3_1.Document {
     for (const path in openapi.paths) {
         const filteredMethods = {} as OpenAPIV3_1.PathItemObject;
         for (const method in openapi.paths[path]) {
-            if (allowedOperations.includes(openapi.paths[path][method].operationId)) {
-                filteredMethods[method] = openapi.paths[path][method];
+            if (allowedOperations.includes((openapi.paths[path][method] as { operationId: string }).operationId)) {
+                filteredMethods[method] = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
             }
         }
         if (Object.keys(filteredMethods).length > 0) {

package/src/common/atlas/apiClient.ts

@@ -1,16 +1,22 @@
-import config from "../../config.js";
-import createClient, { Client, FetchOptions, Middleware } from "openapi-fetch";
+import createClient, { Client, Middleware } from "openapi-fetch";
+import type { FetchOptions } from "openapi-fetch";
 import { AccessToken, ClientCredentials } from "simple-oauth2";
 import { ApiClientError } from "./apiClientError.js";
 import { paths, operations } from "./openapi.js";
+import { BaseEvent } from "../../telemetry/types.js";
+import { mongoLogId } from "mongodb-log-writer";
+import logger from "../../logger.js";
+import { packageInfo } from "../../packageInfo.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
 
+export interface ApiClientCredentials {
+    clientId: string;
+    clientSecret: string;
+}
+
 export interface ApiClientOptions {
-    credentials?: {
-        clientId: string;
-        clientSecret: string;
-    };
+    credentials?: ApiClientCredentials;
     baseUrl?: string;
     userAgent?: string;
 }
@@ -65,7 +71,7 @@ export class ApiClient {
             baseUrl: options?.baseUrl || "https://cloud.mongodb.com/",
             userAgent:
                 options?.userAgent ||
-                `AtlasMCP/${config.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
+                `AtlasMCP/${packageInfo.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
         };
 
         this.client = createClient<paths>({
@@ -91,6 +97,15 @@ export class ApiClient {
         this.client.use(this.errorMiddleware);
     }
 
+    public hasCredentials(): boolean {
+        logger.info(
+            mongoLogId(1_000_000),
+            "api-client",
+            `Checking if API client has credentials: ${!!(this.oauth2Client && this.accessToken)}`
+        );
+        return !!(this.oauth2Client && this.accessToken);
+    }
+
     public async getIpInfo(): Promise<{
         currentIpv4Address: string;
     }> {
@@ -116,6 +131,32 @@ export class ApiClient {
         }>;
     }
 
+    async sendEvents(events: BaseEvent[]): Promise<void> {
+        let endpoint = "api/private/unauth/telemetry/events";
+        const headers: Record<string, string> = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": this.options.userAgent,
+        };
+
+        const accessToken = await this.getAccessToken();
+        if (accessToken) {
+            endpoint = "api/private/v1.0/telemetry/events";
+            headers["Authorization"] = `Bearer ${accessToken}`;
+        }
+
+        const url = new URL(endpoint, this.options.baseUrl);
+        const response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(events),
+        });
+
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+    }
+
     // DO NOT EDIT. This is auto-generated code.
     async listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>) {
         const { data } = await this.client.GET("/api/atlas/v2/clusters", options);

package/src/config.ts

@@ -2,15 +2,15 @@ import path from "path";
 import os from "os";
 import argv from "yargs-parser";
 
-import packageJson from "../package.json" with { type: "json" };
 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.
-interface UserConfig {
+export interface UserConfig {
     apiBaseUrl?: string;
     apiClientId?: string;
     apiClientSecret?: string;
+    telemetry?: "enabled" | "disabled";
     logPath: string;
     connectionString?: string;
     connectOptions: {
@@ -31,21 +31,15 @@ const defaults: UserConfig = {
         timeoutMS: 30_000,
     },
     disabledTools: [],
+    telemetry: "disabled",
 };
 
-const mergedUserConfig = {
+export const config = {
     ...defaults,
     ...getEnvConfig(),
     ...getCliConfig(),
 };
 
-const config = {
-    ...mergedUserConfig,
-    version: packageJson.version,
-};
-
-export default config;
-
 function getLogPath(): string {
     const localDataPath =
         process.platform === "win32"

package/src/index.ts

@@ -4,20 +4,25 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import logger from "./logger.js";
 import { mongoLogId } from "mongodb-log-writer";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import config from "./config.js";
+import { config } from "./config.js";
 import { Session } from "./session.js";
 import { Server } from "./server.js";
+import { packageInfo } from "./packageInfo.js";
 
 try {
-    const session = new Session();
+    const session = new Session({
+        apiBaseUrl: config.apiBaseUrl,
+        apiClientId: config.apiClientId,
+        apiClientSecret: config.apiClientSecret,
+    });
     const mcpServer = new McpServer({
-        name: "MongoDB Atlas",
-        version: config.version,
+        name: packageInfo.mcpServerName,
+        version: packageInfo.version,
     });
-
     const server = new Server({
         mcpServer,
         session,
+        userConfig: config,
     });
 
     const transport = new StdioServerTransport();
@@ -25,6 +30,5 @@ try {
     await server.connect(transport);
 } catch (error: unknown) {
     logger.emergency(mongoLogId(1_000_004), "server", `Fatal error running server: ${error as string}`);
-
     process.exit(1);
 }

package/src/logger.ts

@@ -1,6 +1,5 @@
 import fs from "fs/promises";
 import { MongoLogId, MongoLogManager, MongoLogWriter } from "mongodb-log-writer";
-import config from "./config.js";
 import redact from "mongodb-redact";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { LoggingMessageNotification } from "@modelcontextprotocol/sdk/types.js";
@@ -9,6 +8,7 @@ export type LogLevel = LoggingMessageNotification["params"]["level"];
 
 abstract class LoggerBase {
     abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
+
     info(id: MongoLogId, context: string, message: string): void {
         this.log("info", id, context, message);
     }
@@ -48,22 +48,35 @@ class ConsoleLogger extends LoggerBase {
     }
 }
 
-class Logger extends LoggerBase {
-    constructor(
-        private logWriter: MongoLogWriter,
-        private server: McpServer
-    ) {
+class DiskLogger extends LoggerBase {
+    private constructor(private logWriter: MongoLogWriter) {
         super();
     }
 
+    static async fromPath(logPath: string): Promise<DiskLogger> {
+        await fs.mkdir(logPath, { recursive: true });
+
+        const manager = new MongoLogManager({
+            directory: logPath,
+            retentionDays: 30,
+            onwarn: console.warn,
+            onerror: console.error,
+            gzip: false,
+            retentionGB: 1,
+        });
+
+        await manager.cleanupOldLogFiles();
+
+        const logWriter = await manager.createLogWriter();
+
+        return new DiskLogger(logWriter);
+    }
+
     log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
         message = redact(message);
         const mongoDBLevel = this.mapToMongoDBLogLevel(level);
+
         this.logWriter[mongoDBLevel]("MONGODB-MCP", id, context, message);
-        void this.server.server.sendLoggingMessage({
-            level,
-            data: `[${context}]: ${message}`,
-        });
     }
 
     private mapToMongoDBLogLevel(level: LogLevel): "info" | "warn" | "error" | "debug" | "fatal" {
@@ -87,31 +100,56 @@ class Logger extends LoggerBase {
     }
 }
 
-class ProxyingLogger extends LoggerBase {
-    private internalLogger: LoggerBase = new ConsoleLogger();
+class McpLogger extends LoggerBase {
+    constructor(private server: McpServer) {
+        super();
+    }
+
+    log(level: LogLevel, _: MongoLogId, context: string, message: string): void {
+        void this.server.server.sendLoggingMessage({
+            level,
+            data: `[${context}]: ${message}`,
+        });
+    }
+}
+
+class CompositeLogger extends LoggerBase {
+    private loggers: LoggerBase[];
+
+    constructor(...loggers: LoggerBase[]) {
+        super();
+
+        if (loggers.length === 0) {
+            // default to ConsoleLogger
+            this.loggers = [new ConsoleLogger()];
+            return;
+        }
+
+        this.loggers = [...loggers];
+    }
+
+    setLoggers(...loggers: LoggerBase[]): void {
+        if (loggers.length === 0) {
+            throw new Error("At least one logger must be provided");
+        }
+        this.loggers = [...loggers];
+    }
 
     log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
-        this.internalLogger.log(level, id, context, message);
+        for (const logger of this.loggers) {
+            logger.log(level, id, context, message);
+        }
     }
 }
 
-const logger = new ProxyingLogger();
+const logger = new CompositeLogger();
 export default logger;
 
-export async function initializeLogger(server: McpServer): Promise<void> {
-    await fs.mkdir(config.logPath, { recursive: true });
-
-    const manager = new MongoLogManager({
-        directory: config.logPath,
-        retentionDays: 30,
-        onwarn: console.warn,
-        onerror: console.error,
-        gzip: false,
-        retentionGB: 1,
-    });
+export async function initializeLogger(server: McpServer, logPath: string): Promise<LoggerBase> {
+    const diskLogger = await DiskLogger.fromPath(logPath);
+    const mcpLogger = new McpLogger(server);
 
-    await manager.cleanupOldLogFiles();
+    logger.setLoggers(mcpLogger, diskLogger);
 
-    const logWriter = await manager.createLogWriter();
-    logger["internalLogger"] = new Logger(logWriter, server);
+    return logger;
 }

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+import packageJson from "../package.json" with { type: "json" };
+
+export const packageInfo = {
+    version: packageJson.version,
+    mcpServerName: "MongoDB MCP Server",
+};

package/src/server.ts

@@ -5,28 +5,89 @@ 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 config from "./config.js";
+import { ObjectId } from "mongodb";
+import { Telemetry } from "./telemetry/telemetry.js";
+import { UserConfig } from "./config.js";
+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";
+
+export interface ServerOptions {
+    session: Session;
+    userConfig: UserConfig;
+    mcpServer: McpServer;
+}
 
 export class Server {
     public readonly session: Session;
     private readonly mcpServer: McpServer;
+    private readonly telemetry: Telemetry;
+    private readonly userConfig: UserConfig;
+    private readonly startTime: number;
 
-    constructor({ mcpServer, session }: { mcpServer: McpServer; session: Session }) {
-        this.mcpServer = mcpServer;
+    constructor({ session, mcpServer, userConfig }: ServerOptions) {
+        this.startTime = Date.now();
         this.session = session;
+        this.telemetry = new Telemetry(session);
+        this.mcpServer = mcpServer;
+        this.userConfig = userConfig;
     }
 
     async connect(transport: Transport) {
         this.mcpServer.server.registerCapabilities({ logging: {} });
-
         this.registerTools();
         this.registerResources();
 
-        await initializeLogger(this.mcpServer);
+        // This is a workaround for an issue we've seen with some models, where they'll see that everything in the `arguments`
+        // object is optional, and then not pass it at all. However, the MCP server expects the `arguments` object to be if
+        // the tool accepts any arguments, even if they're all optional.
+        //
+        // see: https://github.com/modelcontextprotocol/typescript-sdk/blob/131776764536b5fdca642df51230a3746fb4ade0/src/server/mcp.ts#L705
+        // Since paramsSchema here is not undefined, the server will create a non-optional z.object from it.
+        const existingHandler = (
+            this.mcpServer.server["_requestHandlers"] as Map<
+                string,
+                (request: unknown, extra: unknown) => Promise<CallToolResult>
+            >
+        ).get(CallToolRequestSchema.shape.method.value);
+
+        assert(existingHandler, "No existing handler found for CallToolRequestSchema");
+
+        this.mcpServer.server.setRequestHandler(CallToolRequestSchema, (request, extra): Promise<CallToolResult> => {
+            if (!request.params.arguments) {
+                request.params.arguments = {};
+            }
+
+            return existingHandler(request, extra);
+        });
+
+        await initializeLogger(this.mcpServer, this.userConfig.logPath);
 
         await this.mcpServer.connect(transport);
 
-        logger.info(mongoLogId(1_000_004), "server", `Server started with transport ${transport.constructor.name}`);
+        this.mcpServer.server.oninitialized = () => {
+            this.session.setAgentRunner(this.mcpServer.server.getClientVersion());
+            this.session.sessionId = new ObjectId().toString();
+
+            logger.info(
+                mongoLogId(1_000_004),
+                "server",
+                `Server started with transport ${transport.constructor.name} and agent runner ${this.session.agentRunner?.name}`
+            );
+
+            this.emitServerEvent("start", Date.now() - this.startTime);
+        };
+
+        this.mcpServer.server.onclose = () => {
+            const closeTime = Date.now();
+            this.emitServerEvent("stop", Date.now() - closeTime);
+        };
+
+        this.mcpServer.server.onerror = (error: Error) => {
+            const closeTime = Date.now();
+            this.emitServerEvent("stop", Date.now() - closeTime, error);
+        };
     }
 
     async close(): Promise<void> {
@@ -34,14 +95,47 @@ export class Server {
         await this.mcpServer.close();
     }
 
+    /**
+     * Emits a server event
+     * @param command - The server command (e.g., "start", "stop", "register", "deregister")
+     * @param additionalProperties - Additional properties specific to the event
+     */
+    emitServerEvent(command: ServerCommand, commandDuration: number, error?: Error) {
+        const event: ServerEvent = {
+            timestamp: new Date().toISOString(),
+            source: "mdbmcp",
+            properties: {
+                ...this.telemetry.getCommonProperties(),
+                result: "success",
+                duration_ms: commandDuration,
+                component: "server",
+                category: "other",
+                command: command,
+            },
+        };
+
+        if (command === "start") {
+            event.properties.startup_time_ms = commandDuration;
+        }
+        if (command === "stop") {
+            event.properties.runtime_duration_ms = Date.now() - this.startTime;
+            if (error) {
+                event.properties.result = "failure";
+                event.properties.reason = error.message;
+            }
+        }
+
+        this.telemetry.emitEvents([event]).catch(() => {});
+    }
+
     private registerTools() {
         for (const tool of [...AtlasTools, ...MongoDbTools]) {
-            new tool(this.session).register(this.mcpServer);
+            new tool(this.session, this.userConfig, this.telemetry).register(this.mcpServer);
         }
     }
 
     private registerResources() {
-        if (config.connectionString) {
+        if (this.userConfig.connectionString) {
             this.mcpServer.resource(
                 "connection-string",
                 "config://connection-string",
@@ -52,7 +146,7 @@ export class Server {
                     return {
                         contents: [
                             {
-                                text: `Preconfigured connection string: ${config.connectionString}`,
+                                text: `Preconfigured connection string: ${this.userConfig.connectionString}`,
                                 uri: uri.href,
                             },
                         ],