mongodb-mcp-server 0.1.2 → 0.2.0

package/src/transports/streamableHttp.ts

@@ -0,0 +1,178 @@
+import express from "express";
+import http from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { TransportRunnerBase } from "./base.js";
+import { UserConfig } from "../common/config.js";
+import logger, { LogId } from "../common/logger.js";
+import { randomUUID } from "crypto";
+import { SessionStore } from "../common/sessionStore.js";
+
+const JSON_RPC_ERROR_CODE_PROCESSING_REQUEST_FAILED = -32000;
+const JSON_RPC_ERROR_CODE_SESSION_ID_REQUIRED = -32001;
+const JSON_RPC_ERROR_CODE_SESSION_ID_INVALID = -32002;
+const JSON_RPC_ERROR_CODE_SESSION_NOT_FOUND = -32003;
+const JSON_RPC_ERROR_CODE_INVALID_REQUEST = -32004;
+
+function withErrorHandling(
+    fn: (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<void>
+) {
+    return (req: express.Request, res: express.Response, next: express.NextFunction) => {
+        fn(req, res, next).catch((error) => {
+            logger.error(
+                LogId.streamableHttpTransportRequestFailure,
+                "streamableHttpTransport",
+                `Error handling request: ${error instanceof Error ? error.message : String(error)}`
+            );
+            res.status(400).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: JSON_RPC_ERROR_CODE_PROCESSING_REQUEST_FAILED,
+                    message: `failed to handle request`,
+                    data: error instanceof Error ? error.message : String(error),
+                },
+            });
+        });
+    };
+}
+
+export class StreamableHttpRunner extends TransportRunnerBase {
+    private httpServer: http.Server | undefined;
+    private sessionStore: SessionStore;
+
+    constructor(private userConfig: UserConfig) {
+        super();
+        this.sessionStore = new SessionStore(this.userConfig.idleTimeoutMs, this.userConfig.notificationTimeoutMs);
+    }
+
+    async start() {
+        const app = express();
+        app.enable("trust proxy"); // needed for reverse proxy support
+        app.use(express.json());
+
+        const handleSessionRequest = async (req: express.Request, res: express.Response) => {
+            const sessionId = req.headers["mcp-session-id"];
+            if (!sessionId) {
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: JSON_RPC_ERROR_CODE_SESSION_ID_REQUIRED,
+                        message: `session id is required`,
+                    },
+                });
+                return;
+            }
+            if (typeof sessionId !== "string") {
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: JSON_RPC_ERROR_CODE_SESSION_ID_INVALID,
+                        message: `session id is invalid`,
+                    },
+                });
+                return;
+            }
+            const transport = this.sessionStore.getSession(sessionId);
+            if (!transport) {
+                res.status(404).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: JSON_RPC_ERROR_CODE_SESSION_NOT_FOUND,
+                        message: `session not found`,
+                    },
+                });
+                return;
+            }
+            await transport.handleRequest(req, res, req.body);
+        };
+
+        app.post(
+            "/mcp",
+            withErrorHandling(async (req: express.Request, res: express.Response) => {
+                const sessionId = req.headers["mcp-session-id"];
+                if (sessionId) {
+                    await handleSessionRequest(req, res);
+                    return;
+                }
+
+                if (!isInitializeRequest(req.body)) {
+                    res.status(400).json({
+                        jsonrpc: "2.0",
+                        error: {
+                            code: JSON_RPC_ERROR_CODE_INVALID_REQUEST,
+                            message: `invalid request`,
+                        },
+                    });
+                    return;
+                }
+
+                const server = this.setupServer(this.userConfig);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID().toString(),
+                    onsessioninitialized: (sessionId) => {
+                        this.sessionStore.setSession(sessionId, transport, server.mcpServer);
+                    },
+                    onsessionclosed: async (sessionId) => {
+                        try {
+                            await this.sessionStore.closeSession(sessionId, false);
+                        } catch (error) {
+                            logger.error(
+                                LogId.streamableHttpTransportSessionCloseFailure,
+                                "streamableHttpTransport",
+                                `Error closing session: ${error instanceof Error ? error.message : String(error)}`
+                            );
+                        }
+                    },
+                });
+
+                transport.onclose = () => {
+                    server.close().catch((error) => {
+                        logger.error(
+                            LogId.streamableHttpTransportCloseFailure,
+                            "streamableHttpTransport",
+                            `Error closing server: ${error instanceof Error ? error.message : String(error)}`
+                        );
+                    });
+                };
+
+                await server.connect(transport);
+
+                await transport.handleRequest(req, res, req.body);
+            })
+        );
+
+        app.get("/mcp", withErrorHandling(handleSessionRequest));
+        app.delete("/mcp", withErrorHandling(handleSessionRequest));
+
+        this.httpServer = await new Promise<http.Server>((resolve, reject) => {
+            const result = app.listen(this.userConfig.httpPort, this.userConfig.httpHost, (err?: Error) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+
+        logger.info(
+            LogId.streamableHttpTransportStarted,
+            "streamableHttpTransport",
+            `Server started on http://${this.userConfig.httpHost}:${this.userConfig.httpPort}`
+        );
+    }
+
+    async close(): Promise<void> {
+        await Promise.all([
+            this.sessionStore.closeAllSessions(),
+            new Promise<void>((resolve, reject) => {
+                this.httpServer?.close((err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            }),
+        ]);
+    }
+}

package/tests/accuracy/aggregate.test.ts

@@ -0,0 +1,27 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+import { Matcher } from "./sdk/matcher.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Group all the movies in 'mflix.movies' namespace by 'release_year' and give me a count of them",
+        expectedToolCalls: [
+            {
+                toolName: "aggregate",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    pipeline: [
+                        { $group: { _id: "$release_year", count: { $sum: 1 } } },
+                        // For the sake of accuracy, we allow any sort order
+                        Matcher.anyOf(
+                            Matcher.undefined,
+                            Matcher.value({
+                                $sort: Matcher.anyValue,
+                            })
+                        ),
+                    ],
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/collectionIndexes.test.ts

@@ -0,0 +1,40 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+
+describeAccuracyTests([
+    {
+        prompt: "How many indexes do I have in 'mflix.movies' namespace?",
+        expectedToolCalls: [
+            {
+                toolName: "collection-indexes",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "List all the indexes in movies collection in mflix database",
+        expectedToolCalls: [
+            {
+                toolName: "collection-indexes",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+    {
+        prompt: `Is the following query: ${JSON.stringify({ runtime: { $lt: 100 } })} on the namespace 'mflix.movies' indexed?`,
+        expectedToolCalls: [
+            {
+                toolName: "collection-indexes",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/collectionSchema.test.ts

@@ -0,0 +1,28 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Is there a title field in 'mflix.movies' namespace?",
+        expectedToolCalls: [
+            {
+                toolName: "collection-schema",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "What is the type of value stored in title field in movies collection in mflix database?",
+        expectedToolCalls: [
+            {
+                toolName: "collection-schema",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/collectionStorageSize.test.ts

@@ -0,0 +1,41 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+
+describeAccuracyTests([
+    {
+        prompt: "What is the size of 'mflix.movies' namespace",
+        expectedToolCalls: [
+            {
+                toolName: "collection-storage-size",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "How much size is each collection in comics database",
+        expectedToolCalls: [
+            {
+                toolName: "list-collections",
+                parameters: {
+                    database: "comics",
+                },
+            },
+            {
+                toolName: "collection-storage-size",
+                parameters: {
+                    database: "comics",
+                    collection: "books",
+                },
+            },
+            {
+                toolName: "collection-storage-size",
+                parameters: {
+                    database: "comics",
+                    collection: "characters",
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/count.test.ts

@@ -0,0 +1,44 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+import { Matcher } from "./sdk/matcher.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Count number of documents in 'mflix.movies' namespace.",
+        expectedToolCalls: [
+            {
+                toolName: "count",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    query: Matcher.emptyObjectOrUndefined,
+                },
+            },
+        ],
+    },
+    {
+        prompt: "How many documents are there in 'characters' collection in 'comics' database?",
+        expectedToolCalls: [
+            {
+                toolName: "count",
+                parameters: {
+                    database: "comics",
+                    collection: "characters",
+                    query: Matcher.emptyObjectOrUndefined,
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Count all the documents in 'mflix.movies' namespace with runtime less than 100?",
+        expectedToolCalls: [
+            {
+                toolName: "count",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    query: { runtime: { $lt: 100 } },
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/createCollection.test.ts

@@ -0,0 +1,46 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Create a new namespace 'mflix.documentaries'",
+        expectedToolCalls: [
+            {
+                toolName: "create-collection",
+                parameters: {
+                    database: "mflix",
+                    collection: "documentaries",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Create a new collection villains in comics database",
+        expectedToolCalls: [
+            {
+                toolName: "create-collection",
+                parameters: {
+                    database: "comics",
+                    collection: "villains",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "If and only if, the namespace 'mflix.documentaries' does not exist, then create it",
+        expectedToolCalls: [
+            {
+                toolName: "list-collections",
+                parameters: {
+                    database: "mflix",
+                },
+            },
+            {
+                toolName: "create-collection",
+                parameters: {
+                    database: "mflix",
+                    collection: "documentaries",
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/createIndex.test.ts

@@ -0,0 +1,37 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+import { Matcher } from "./sdk/matcher.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Create an index that covers the following query on 'mflix.movies' namespace - { \"release_year\": 1992 }",
+        expectedToolCalls: [
+            {
+                toolName: "create-index",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    name: Matcher.anyOf(Matcher.undefined, Matcher.string()),
+                    keys: {
+                        release_year: 1,
+                    },
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Create a text index on title field in 'mflix.movies' namespace",
+        expectedToolCalls: [
+            {
+                toolName: "create-index",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    name: Matcher.anyOf(Matcher.undefined, Matcher.string()),
+                    keys: {
+                        title: "text",
+                    },
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/dbStats.test.ts

@@ -0,0 +1,15 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+
+describeAccuracyTests([
+    {
+        prompt: "What is the size occupied by database mflix?",
+        expectedToolCalls: [
+            {
+                toolName: "db-stats",
+                parameters: {
+                    database: "mflix",
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/deleteMany.test.ts

@@ -0,0 +1,44 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+import { Matcher } from "./sdk/matcher.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Delete all the documents from 'mflix.movies' namespace",
+        expectedToolCalls: [
+            {
+                toolName: "delete-many",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    filter: Matcher.emptyObjectOrUndefined,
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Purge the collection 'movies' in database 'mflix'",
+        expectedToolCalls: [
+            {
+                toolName: "delete-many",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    filter: Matcher.emptyObjectOrUndefined,
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Remove all the documents from namespace 'mflix.movies' where runtime is less than 100",
+        expectedToolCalls: [
+            {
+                toolName: "delete-many",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                    filter: { runtime: { $lt: 100 } },
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/dropCollection.test.ts

@@ -0,0 +1,74 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Remove mflix.movies namespace from my cluster.",
+        expectedToolCalls: [
+            {
+                toolName: "drop-collection",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Drop movies collection from mflix database.",
+        expectedToolCalls: [
+            {
+                toolName: "drop-collection",
+                parameters: {
+                    database: "mflix",
+                    collection: "movies",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Remove books collection from which ever database contains it.",
+        expectedToolCalls: [
+            {
+                toolName: "list-databases",
+                parameters: {},
+            },
+            {
+                toolName: "list-collections",
+                parameters: {
+                    database: "admin",
+                },
+            },
+            {
+                toolName: "list-collections",
+                parameters: {
+                    database: "comics",
+                },
+            },
+            {
+                toolName: "list-collections",
+                parameters: {
+                    database: "config",
+                },
+            },
+            {
+                toolName: "list-collections",
+                parameters: {
+                    database: "local",
+                },
+            },
+            {
+                toolName: "list-collections",
+                parameters: {
+                    database: "mflix",
+                },
+            },
+            {
+                toolName: "drop-collection",
+                parameters: {
+                    database: "comics",
+                    collection: "books",
+                },
+            },
+        ],
+    },
+]);

package/tests/accuracy/dropDatabase.test.ts

@@ -0,0 +1,41 @@
+import { describeAccuracyTests } from "./sdk/describeAccuracyTests.js";
+
+describeAccuracyTests([
+    {
+        prompt: "Remove mflix database from my cluster.",
+        expectedToolCalls: [
+            {
+                toolName: "drop-database",
+                parameters: {
+                    database: "mflix",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "Drop database named mflix.",
+        expectedToolCalls: [
+            {
+                toolName: "drop-database",
+                parameters: {
+                    database: "mflix",
+                },
+            },
+        ],
+    },
+    {
+        prompt: "If there is a mflix database in my cluster then drop it.",
+        expectedToolCalls: [
+            {
+                toolName: "list-databases",
+                parameters: {},
+            },
+            {
+                toolName: "drop-database",
+                parameters: {
+                    database: "mflix",
+                },
+            },
+        ],
+    },
+]);