Merge remote-tracking branch 'origin/main' into telemetry-data

Author: blva

README.md

@@ -1,4 +1,4 @@
-# Atlas MCP Server
+# MongoDB MCP Server
 
 A Model Context Protocol server for interacting with MongoDB Atlas. This project implements a Model Context Protocol (MCP) server enabling AI assistants to interact with MongoDB Atlas resources through natural language.
 
@@ -40,7 +40,7 @@ Step 1: Add the mcp server to VSCode configuration
 
 - Press `Cmd + Shift + P` and type `MCP: Add MCP Server` and select it.
 - Select command (Stdio).
-- Input command `npx -y @mongodb-js/mongodb-mcp-server`.
+- Input command `npx -y mongodb-mcp-server`.
 - Choose between user / workspace
 - Add arguments to the file
 
@@ -54,7 +54,7 @@ Note: the file should look like:
             "command": "npx",
             "args": [
                 "-y",
-                "@mongodb-js/mongodb-mcp-server"
+                "mongodb-mcp-server"
             ]
         }
     }
@@ -82,7 +82,7 @@ Paste the mcp server configuration into the file
   "mcpServers": {
     "MongoDB": {
       "command": "npx",
-      "args": ["-y", "@mongodb-js/mongodb-mcp-server"]
+      "args": ["-y", "mongodb-mcp-server"]
     }
   }
 }
@@ -228,7 +228,7 @@ export MDB_MCP_LOG_PATH="/path/to/logs"
 Pass configuration options as command-line arguments when starting the server:
 
 ```shell
-npx -y @mongodb-js/mongodb-mcp-server --apiClientId="your-atlas-client-id" --apiClientSecret="your-atlas-client-secret" --connectionString="mongodb+srv://username:[email protected]/myDatabase" --logPath=/path/to/logs
+npx -y mongodb-mcp-server --apiClientId="your-atlas-client-id" --apiClientSecret="your-atlas-client-secret" --connectionString="mongodb+srv://username:[email protected]/myDatabase" --logPath=/path/to/logs
 ```
 
 ## 🤝 Contributing

package-lock.json

@@ -1,7 +1,7 @@
 {
-  "name": "@mongodb-js/mongodb-mcp-server",
+  "name": "mongodb-mcp-server",
   "description": "MongoDB Model Context Protocol Server",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "main": "dist/index.js",
   "author": "MongoDB <[email protected]>",
   "homepage": "https://github.com/mongodb-js/mongodb-mcp-server",

package.json

@@ -10,6 +10,8 @@ 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;
@@ -37,6 +39,29 @@ export class Server {
         this.registerTools();
         this.registerResources();
 
+        // 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);

src/server.ts

@@ -0,0 +1,55 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { MongoDBToolBase } from "../mongodbTool.js";
+import { ToolArgs, OperationType } from "../../tool.js";
+import { z } from "zod";
+
+export class LogsTool extends MongoDBToolBase {
+    protected name = "mongodb-logs";
+    protected description = "Returns the most recent logged mongod events";
+    protected argsShape = {
+        type: z
+            .enum(["global", "startupWarnings"])
+            .optional()
+            .default("global")
+            .describe(
+                "The type of logs to return. Global returns all recent log entries, while startupWarnings returns only warnings and errors from when the process started."
+            ),
+        limit: z
+            .number()
+            .int()
+            .max(1024)
+            .min(1)
+            .optional()
+            .default(50)
+            .describe("The maximum number of log entries to return."),
+    };
+
+    protected operationType: OperationType = "metadata";
+
+    protected async execute({ type, limit }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const provider = await this.ensureConnected();
+
+        const result = await provider.runCommandWithCheck("admin", {
+            getLog: type,
+        });
+
+        const logs = (result.log as string[]).slice(0, limit);
+
+        return {
+            content: [
+                {
+                    text: `Found: ${result.totalLinesWritten} messages`,
+                    type: "text",
+                },
+
+                ...logs.map(
+                    (log) =>
+                        ({
+                            text: log,
+                            type: "text",
+                        }) as const
+                ),
+            ],
+        };
+    }
+}

src/tools/mongodb/metadata/logs.ts

@@ -17,6 +17,7 @@ import { DropDatabaseTool } from "./delete/dropDatabase.js";
 import { DropCollectionTool } from "./delete/dropCollection.js";
 import { ExplainTool } from "./metadata/explain.js";
 import { CreateCollectionTool } from "./create/createCollection.js";
+import { LogsTool } from "./metadata/logs.js";
 
 export const MongoDbTools = [
     ConnectTool,
@@ -38,4 +39,5 @@ export const MongoDbTools = [
     DropCollectionTool,
     ExplainTool,
     CreateCollectionTool,
+    LogsTool,
 ];

src/tools/mongodb/tools.ts

@@ -101,13 +101,17 @@ export function setupIntegrationTest(userConfig: UserConfig = config): Integrati
     };
 }
 
-export function getResponseContent(content: unknown): string {
+export function getResponseContent(content: unknown | { content: unknown }): string {
     return getResponseElements(content)
         .map((item) => item.text)
         .join("\n");
 }
 
-export function getResponseElements(content: unknown): { type: string; text: string }[] {
+export function getResponseElements(content: unknown | { content: unknown }): { type: string; text: string }[] {
+    if (typeof content === "object" && content !== null && "content" in content) {
+        content = (content as { content: unknown }).content;
+    }
+
     expect(Array.isArray(content)).toBe(true);
 
     const response = content as { type: string; text: string }[];

tests/integration/helpers.ts

@@ -21,7 +21,7 @@ describeWithMongoDB("dropDatabase tool", (integration) => {
     it("can drop non-existing database", async () => {
         let { databases } = await integration.mongoClient().db("").admin().listDatabases();
 
-        const preDropLength = databases.length;
+        expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
 
         await integration.connectMcpClient();
         const response = await integration.mcpClient().callTool({
@@ -36,7 +36,6 @@ describeWithMongoDB("dropDatabase tool", (integration) => {
 
         ({ databases } = await integration.mongoClient().db("").admin().listDatabases());
 
-        expect(databases).toHaveLength(preDropLength);
         expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
     });
 

tests/integration/tools/mongodb/delete/dropDatabase.test.ts

@@ -15,6 +15,23 @@ describeWithMongoDB("Connect tool", (integration) => {
         },
     ]);
 
+    describe("without arguments", () => {
+        it("prompts for connection string if not set", async () => {
+            const response = await integration.mcpClient().callTool({ name: "connect" });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("No connection details provided");
+        });
+
+        it("connects to the database if connection string is set", async () => {
+            config.connectionString = integration.connectionString();
+
+            const response = await integration.mcpClient().callTool({ name: "connect" });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("Successfully connected");
+            expect(content).toContain(integration.connectionString());
+        });
+    });
+
     describe("with default config", () => {
         describe("without connection string", () => {
             it("prompts for connection string", async () => {

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

@@ -82,15 +82,13 @@ describeWithMongoDB("dbStats tool", (integration) => {
         }
     });
 
-    describe("when not connected", () => {
-        validateAutoConnectBehavior(integration, "db-stats", () => {
-            return {
-                args: {
-                    database: integration.randomDbName(),
-                    collection: "foo",
-                },
-                expectedResponse: `Statistics for database ${integration.randomDbName()}`,
-            };
-        });
+    validateAutoConnectBehavior(integration, "db-stats", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "foo",
+            },
+            expectedResponse: `Statistics for database ${integration.randomDbName()}`,
+        };
     });
 });