mongodb-mcp-server 0.2.0 → 0.3.0

package/src/transports/stdio.ts

@@ -1,76 +0,0 @@
-import logger, { LogId } from "../common/logger.js";
-import { Server } from "../server.js";
-import { TransportRunnerBase } from "./base.js";
-import { JSONRPCMessage, JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
-import { EJSON } from "bson";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { UserConfig } from "../common/config.js";
-
-// This is almost a copy of ReadBuffer from @modelcontextprotocol/sdk
-// but it uses EJSON.parse instead of JSON.parse to handle BSON types
-export class EJsonReadBuffer {
-    private _buffer?: Buffer;
-
-    append(chunk: Buffer): void {
-        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
-    }
-
-    readMessage(): JSONRPCMessage | null {
-        if (!this._buffer) {
-            return null;
-        }
-
-        const index = this._buffer.indexOf("\n");
-        if (index === -1) {
-            return null;
-        }
-
-        const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
-        this._buffer = this._buffer.subarray(index + 1);
-
-        // This is using EJSON.parse instead of JSON.parse to handle BSON types
-        return JSONRPCMessageSchema.parse(EJSON.parse(line));
-    }
-
-    clear(): void {
-        this._buffer = undefined;
-    }
-}
-
-// This is a hacky workaround for https://github.com/mongodb-js/mongodb-mcp-server/issues/211
-// The underlying issue is that StdioServerTransport uses JSON.parse to deserialize
-// messages, but that doesn't handle bson types, such as ObjectId when serialized as EJSON.
-//
-// This function creates a StdioServerTransport and replaces the internal readBuffer with EJsonReadBuffer
-// that uses EJson.parse instead.
-export function createStdioTransport(): StdioServerTransport {
-    const server = new StdioServerTransport();
-    server["_readBuffer"] = new EJsonReadBuffer();
-
-    return server;
-}
-
-export class StdioRunner extends TransportRunnerBase {
-    private server: Server | undefined;
-
-    constructor(private userConfig: UserConfig) {
-        super();
-    }
-
-    async start() {
-        try {
-            this.server = this.setupServer(this.userConfig);
-
-            const transport = createStdioTransport();
-
-            await this.server.connect(transport);
-        } catch (error: unknown) {
-            logger.emergency(LogId.serverStartFailure, "server", `Fatal error running server: ${error as string}`);
-            process.exit(1);
-        }
-    }
-
-    async close(): Promise<void> {
-        await this.server?.close();
-    }
-}

package/src/transports/streamableHttp.ts

@@ -1,178 +0,0 @@
-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/src/types/mongodb-connection-string-url.d.ts

@@ -1,69 +0,0 @@
-declare module "mongodb-connection-string-url" {
-    import { URL } from "whatwg-url";
-    import { redactConnectionString, ConnectionStringRedactionOptions } from "./redact";
-    export { redactConnectionString, ConnectionStringRedactionOptions };
-    declare class CaseInsensitiveMap<K extends string = string> extends Map<K, string> {
-        delete(name: K): boolean;
-        get(name: K): string | undefined;
-        has(name: K): boolean;
-        set(name: K, value: any): this;
-        _normalizeKey(name: any): K;
-    }
-    declare abstract class URLWithoutHost extends URL {
-        abstract get host(): never;
-        abstract set host(value: never);
-        abstract get hostname(): never;
-        abstract set hostname(value: never);
-        abstract get port(): never;
-        abstract set port(value: never);
-        abstract get href(): string;
-        abstract set href(value: string);
-    }
-    export interface ConnectionStringParsingOptions {
-        looseValidation?: boolean;
-    }
-    export declare class ConnectionString extends URLWithoutHost {
-        _hosts: string[];
-        constructor(uri: string, options?: ConnectionStringParsingOptions);
-        get host(): never;
-        set host(_ignored: never);
-        get hostname(): never;
-        set hostname(_ignored: never);
-        get port(): never;
-        set port(_ignored: never);
-        get href(): string;
-        set href(_ignored: string);
-        get isSRV(): boolean;
-        get hosts(): string[];
-        set hosts(list: string[]);
-        toString(): string;
-        clone(): ConnectionString;
-        redact(options?: ConnectionStringRedactionOptions): ConnectionString;
-        typedSearchParams<T extends {}>(): {
-            append(name: keyof T & string, value: any): void;
-            delete(name: keyof T & string): void;
-            get(name: keyof T & string): string | null;
-            getAll(name: keyof T & string): string[];
-            has(name: keyof T & string): boolean;
-            set(name: keyof T & string, value: any): void;
-            keys(): IterableIterator<keyof T & string>;
-            values(): IterableIterator<string>;
-            entries(): IterableIterator<[keyof T & string, string]>;
-            _normalizeKey(name: keyof T & string): string;
-            [Symbol.iterator](): IterableIterator<[keyof T & string, string]>;
-            sort(): void;
-            forEach<THIS_ARG = void>(
-                callback: (this: THIS_ARG, value: string, name: string, searchParams: any) => void,
-                thisArg?: THIS_ARG | undefined
-            ): void;
-            readonly [Symbol.toStringTag]: "URLSearchParams";
-        };
-    }
-    export declare class CommaAndColonSeparatedRecord<
-        K extends {} = Record<string, unknown>,
-    > extends CaseInsensitiveMap<keyof K & string> {
-        constructor(from?: string | null);
-        toString(): string;
-    }
-    export default ConnectionString;
-}

package/src/types/mongodb-redact.d.ts

@@ -1,4 +0,0 @@
-declare module "mongodb-redact" {
-    function redact<T>(message: T): T;
-    export default redact;
-}

package/tests/accuracy/aggregate.test.ts

@@ -1,27 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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 } },
-                },
-            },
-        ],
-    },
-]);