@himanshusinghs/mongodb-mcp-server 0.3.0

package/dist/cjs/tools/mongodb/mongodbTool.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDBToolBase = exports.DbOperationArgs = void 0;
+const zod_1 = require("zod");
+const tool_js_1 = require("../tool.js");
+const errors_js_1 = require("../../common/errors.js");
+const logger_js_1 = require("../../common/logger.js");
+exports.DbOperationArgs = {
+    database: zod_1.z.string().describe("Database name"),
+    collection: zod_1.z.string().describe("Collection name"),
+};
+class MongoDBToolBase extends tool_js_1.ToolBase {
+    constructor() {
+        super(...arguments);
+        this.category = "mongodb";
+    }
+    async ensureConnected() {
+        if (!this.session.isConnectedToMongoDB) {
+            if (this.session.connectedAtlasCluster) {
+                throw new errors_js_1.MongoDBError(errors_js_1.ErrorCodes.NotConnectedToMongoDB, `Attempting to connect to Atlas cluster "${this.session.connectedAtlasCluster.clusterName}", try again in a few seconds.`);
+            }
+            if (this.config.connectionString) {
+                try {
+                    await this.connectToMongoDB(this.config.connectionString);
+                }
+                catch (error) {
+                    this.session.logger.error({
+                        id: logger_js_1.LogId.mongodbConnectFailure,
+                        context: "mongodbTool",
+                        message: `Failed to connect to MongoDB instance using the connection string from the config: ${error}`,
+                    });
+                    throw new errors_js_1.MongoDBError(errors_js_1.ErrorCodes.MisconfiguredConnectionString, "Not connected to MongoDB.");
+                }
+            }
+        }
+        if (!this.session.isConnectedToMongoDB) {
+            throw new errors_js_1.MongoDBError(errors_js_1.ErrorCodes.NotConnectedToMongoDB, "Not connected to MongoDB");
+        }
+        return this.session.serviceProvider;
+    }
+    register(server) {
+        this.server = server;
+        return super.register(server);
+    }
+    handleError(error, args) {
+        if (error instanceof errors_js_1.MongoDBError) {
+            const connectTools = this.server?.tools
+                .filter((t) => t.operationType === "connect")
+                .sort((a, b) => a.category.localeCompare(b.category)); // Sort Altas tools before MongoDB tools
+            // Find the first Atlas connect tool if available and suggest to the LLM to use it.
+            // Note: if we ever have multiple Atlas connect tools, we may want to refine this logic to select the most appropriate one.
+            const atlasConnectTool = connectTools?.find((t) => t.category === "atlas");
+            const llmConnectHint = atlasConnectTool
+                ? `Note to LLM: prefer using the "${atlasConnectTool.name}" tool to connect to an Atlas cluster over using a connection string. Make sure to ask the user to specify a cluster name they want to connect to or ask them if they want to use the "list-clusters" tool to list all their clusters. Do not invent cluster names or connection strings unless the user has explicitly specified them. If they've previously connected to MongoDB using MCP, you can ask them if they want to reconnect using the same cluster/connection.`
+                : "Note to LLM: do not invent connection strings and explicitly ask the user to provide one. If they have previously connected to MongoDB using MCP, you can ask them if they want to reconnect using the same connection string.";
+            const connectToolsNames = connectTools?.map((t) => `"${t.name}"`).join(", ");
+            const connectionStatus = this.session.connectionManager.currentConnectionState;
+            const additionalPromptForConnectivity = [];
+            if (connectionStatus.tag === "connecting" && connectionStatus.oidcConnectionType) {
+                additionalPromptForConnectivity.push({
+                    type: "text",
+                    text: `The user needs to finish their OIDC connection by opening '${connectionStatus.oidcLoginUrl}' in the browser and use the following user code: '${connectionStatus.oidcUserCode}'`,
+                });
+            }
+            else {
+                additionalPromptForConnectivity.push({
+                    type: "text",
+                    text: connectToolsNames
+                        ? `Please use one of the following tools: ${connectToolsNames} to connect to a MongoDB instance or update the MCP server configuration to include a connection string. ${llmConnectHint}`
+                        : "There are no tools available to connect. Please update the configuration to include a connection string and restart the server.",
+                });
+            }
+            switch (error.code) {
+                case errors_js_1.ErrorCodes.NotConnectedToMongoDB:
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "You need to connect to a MongoDB instance before you can access its data.",
+                            },
+                            ...additionalPromptForConnectivity,
+                        ],
+                        isError: true,
+                    };
+                case errors_js_1.ErrorCodes.MisconfiguredConnectionString:
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "The configured connection string is not valid. Please check the connection string and confirm it points to a valid MongoDB instance.",
+                            },
+                            {
+                                type: "text",
+                                text: connectTools
+                                    ? `Alternatively, you can use one of the following tools: ${connectToolsNames} to connect to a MongoDB instance. ${llmConnectHint}`
+                                    : "Please update the configuration to use a valid connection string and restart the server.",
+                            },
+                        ],
+                        isError: true,
+                    };
+                case errors_js_1.ErrorCodes.ForbiddenCollscan:
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: error.message,
+                            },
+                        ],
+                        isError: true,
+                    };
+            }
+        }
+        return super.handleError(error, args);
+    }
+    connectToMongoDB(connectionString) {
+        return this.session.connectToMongoDB({ connectionString });
+    }
+    resolveTelemetryMetadata(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    args) {
+        const metadata = {};
+        // Add projectId to the metadata if running a MongoDB operation to an Atlas cluster
+        if (this.session.connectedAtlasCluster?.projectId) {
+            metadata.projectId = this.session.connectedAtlasCluster.projectId;
+        }
+        return metadata;
+    }
+}
+exports.MongoDBToolBase = MongoDBToolBase;
+//# sourceMappingURL=mongodbTool.js.map

package/dist/cjs/tools/mongodb/mongodbTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodbTool.js","sourceRoot":"","sources":["../../../../src/tools/mongodb/mongodbTool.ts"],"names":[],"mappings":"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"}

package/dist/cjs/tools/mongodb/read/aggregate.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { MongoDBToolBase } from "../mongodbTool.js";
+import type { ToolArgs, OperationType } from "../../tool.js";
+export declare const AggregateArgs: {
+    pipeline: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+};
+export declare class AggregateTool extends MongoDBToolBase {
+    name: string;
+    protected description: string;
+    protected argsShape: {
+        pipeline: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+        database: z.ZodString;
+        collection: z.ZodString;
+    };
+    operationType: OperationType;
+    protected execute({ database, collection, pipeline, }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult>;
+}
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/cjs/tools/mongodb/read/aggregate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAmB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAK7D,eAAO,MAAM,aAAa;;CAEzB,CAAC;AAEF,qBAAa,aAAc,SAAQ,eAAe;IACvC,IAAI,SAAe;IAC1B,SAAS,CAAC,WAAW,SAAqD;IAC1E,SAAS,CAAC,SAAS;;;;MAGjB;IACK,aAAa,EAAE,aAAa,CAAU;cAE7B,OAAO,CAAC,EACpB,QAAQ,EACR,UAAU,EACV,QAAQ,GACX,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;CAqB/D"}

package/dist/cjs/tools/mongodb/read/aggregate.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateTool = exports.AggregateArgs = void 0;
+const zod_1 = require("zod");
+const mongodbTool_js_1 = require("../mongodbTool.js");
+const tool_js_1 = require("../../tool.js");
+const indexCheck_js_1 = require("../../../helpers/indexCheck.js");
+const bson_1 = require("bson");
+exports.AggregateArgs = {
+    pipeline: zod_1.z.array(zod_1.z.object({}).passthrough()).describe("An array of aggregation stages to execute"),
+};
+class AggregateTool extends mongodbTool_js_1.MongoDBToolBase {
+    constructor() {
+        super(...arguments);
+        this.name = "aggregate";
+        this.description = "Run an aggregation against a MongoDB collection";
+        this.argsShape = {
+            ...mongodbTool_js_1.DbOperationArgs,
+            ...exports.AggregateArgs,
+        };
+        this.operationType = "read";
+    }
+    async execute({ database, collection, pipeline, }) {
+        const provider = await this.ensureConnected();
+        // Check if aggregate operation uses an index if enabled
+        if (this.config.indexCheck) {
+            await (0, indexCheck_js_1.checkIndexUsage)(provider, database, collection, "aggregate", async () => {
+                return provider
+                    .aggregate(database, collection, pipeline, {}, { writeConcern: undefined })
+                    .explain("queryPlanner");
+            });
+        }
+        const documents = await provider.aggregate(database, collection, pipeline).toArray();
+        return {
+            content: (0, tool_js_1.formatUntrustedData)(`The aggregation resulted in ${documents.length} documents.`, documents.length > 0 ? bson_1.EJSON.stringify(documents) : undefined),
+        };
+    }
+}
+exports.AggregateTool = AggregateTool;
+//# sourceMappingURL=aggregate.js.map

package/dist/cjs/tools/mongodb/read/aggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate.js","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/aggregate.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,sDAAqE;AAErE,2CAAoD;AACpD,kEAAiE;AACjE,+BAA6B;AAEhB,QAAA,aAAa,GAAG;IACzB,QAAQ,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,QAAQ,CAAC,2CAA2C,CAAC;CACtG,CAAC;AAEF,MAAa,aAAc,SAAQ,gCAAe;IAAlD;;QACW,SAAI,GAAG,WAAW,CAAC;QAChB,gBAAW,GAAG,iDAAiD,CAAC;QAChE,cAAS,GAAG;YAClB,GAAG,gCAAe;YAClB,GAAG,qBAAa;SACnB,CAAC;QACK,kBAAa,GAAkB,MAAM,CAAC;IA2BjD,CAAC;IAzBa,KAAK,CAAC,OAAO,CAAC,EACpB,QAAQ,EACR,UAAU,EACV,QAAQ,GACsB;QAC9B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAE9C,wDAAwD;QACxD,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YACzB,MAAM,IAAA,+BAAe,EAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,IAAI,EAAE;gBAC1E,OAAO,QAAQ;qBACV,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,YAAY,EAAE,SAAS,EAAE,CAAC;qBAC1E,OAAO,CAAC,cAAc,CAAC,CAAC;YACjC,CAAC,CAAC,CAAC;QACP,CAAC;QAED,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC;QAErF,OAAO;YACH,OAAO,EAAE,IAAA,6BAAmB,EACxB,+BAA+B,SAAS,CAAC,MAAM,aAAa,EAC5D,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,YAAK,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAChE;SACJ,CAAC;IACN,CAAC;CACJ;AAlCD,sCAkCC"}

package/dist/cjs/tools/mongodb/read/collectionIndexes.d.ts

@@ -0,0 +1,15 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
+import type { ToolArgs, OperationType } from "../../tool.js";
+export declare class CollectionIndexesTool extends MongoDBToolBase {
+    name: string;
+    protected description: string;
+    protected argsShape: {
+        database: import("zod").ZodString;
+        collection: import("zod").ZodString;
+    };
+    operationType: OperationType;
+    protected execute({ database, collection }: ToolArgs<typeof DbOperationArgs>): Promise<CallToolResult>;
+    protected handleError(error: unknown, args: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> | CallToolResult;
+}
+//# sourceMappingURL=collectionIndexes.d.ts.map

package/dist/cjs/tools/mongodb/read/collectionIndexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectionIndexes.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/collectionIndexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG7D,qBAAa,qBAAsB,SAAQ,eAAe;IAC/C,IAAI,SAAwB;IACnC,SAAS,CAAC,WAAW,SAA2C;IAChE,SAAS,CAAC,SAAS;;;MAAmB;IAC/B,aAAa,EAAE,aAAa,CAAU;cAE7B,OAAO,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,QAAQ,CAAC,OAAO,eAAe,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;IAgB5G,SAAS,CAAC,WAAW,CACjB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,GACtC,OAAO,CAAC,cAAc,CAAC,GAAG,cAAc;CAc9C"}

package/dist/cjs/tools/mongodb/read/collectionIndexes.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionIndexesTool = void 0;
+const mongodbTool_js_1 = require("../mongodbTool.js");
+const tool_js_1 = require("../../tool.js");
+class CollectionIndexesTool extends mongodbTool_js_1.MongoDBToolBase {
+    constructor() {
+        super(...arguments);
+        this.name = "collection-indexes";
+        this.description = "Describe the indexes for a collection";
+        this.argsShape = mongodbTool_js_1.DbOperationArgs;
+        this.operationType = "read";
+    }
+    async execute({ database, collection }) {
+        const provider = await this.ensureConnected();
+        const indexes = await provider.getIndexes(database, collection);
+        return {
+            content: (0, tool_js_1.formatUntrustedData)(`Found ${indexes.length} indexes in the collection "${collection}":`, indexes.length > 0
+                ? indexes
+                    .map((index) => `Name: "${index.name}", definition: ${JSON.stringify(index.key)}`)
+                    .join("\n")
+                : undefined),
+        };
+    }
+    handleError(error, args) {
+        if (error instanceof Error && "codeName" in error && error.codeName === "NamespaceNotFound") {
+            return {
+                content: [
+                    {
+                        text: `The indexes for "${args.database}.${args.collection}" cannot be determined because the collection does not exist.`,
+                        type: "text",
+                    },
+                ],
+            };
+        }
+        return super.handleError(error, args);
+    }
+}
+exports.CollectionIndexesTool = CollectionIndexesTool;
+//# sourceMappingURL=collectionIndexes.js.map

package/dist/cjs/tools/mongodb/read/collectionIndexes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectionIndexes.js","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/collectionIndexes.ts"],"names":[],"mappings":";;;AACA,sDAAqE;AAErE,2CAAoD;AAEpD,MAAa,qBAAsB,SAAQ,gCAAe;IAA1D;;QACW,SAAI,GAAG,oBAAoB,CAAC;QACzB,gBAAW,GAAG,uCAAuC,CAAC;QACtD,cAAS,GAAG,gCAAe,CAAC;QAC/B,kBAAa,GAAkB,MAAM,CAAC;IAmCjD,CAAC;IAjCa,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAoC;QAC9E,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAC9C,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QAEhE,OAAO;YACH,OAAO,EAAE,IAAA,6BAAmB,EACxB,SAAS,OAAO,CAAC,MAAM,+BAA+B,UAAU,IAAI,EACpE,OAAO,CAAC,MAAM,GAAG,CAAC;gBACd,CAAC,CAAC,OAAO;qBACF,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,UAAU,KAAK,CAAC,IAAI,kBAAkB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;qBACjF,IAAI,CAAC,IAAI,CAAC;gBACjB,CAAC,CAAC,SAAS,CAClB;SACJ,CAAC;IACN,CAAC;IAES,WAAW,CACjB,KAAc,EACd,IAAqC;QAErC,IAAI,KAAK,YAAY,KAAK,IAAI,UAAU,IAAI,KAAK,IAAI,KAAK,CAAC,QAAQ,KAAK,mBAAmB,EAAE,CAAC;YAC1F,OAAO;gBACH,OAAO,EAAE;oBACL;wBACI,IAAI,EAAE,oBAAoB,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,+DAA+D;wBACzH,IAAI,EAAE,MAAM;qBACf;iBACJ;aACJ,CAAC;QACN,CAAC;QAED,OAAO,KAAK,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC1C,CAAC;CACJ;AAvCD,sDAuCC"}

package/dist/cjs/tools/mongodb/read/count.d.ts

@@ -0,0 +1,19 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { MongoDBToolBase } from "../mongodbTool.js";
+import type { ToolArgs, OperationType } from "../../tool.js";
+import { z } from "zod";
+export declare const CountArgs: {
+    query: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+};
+export declare class CountTool extends MongoDBToolBase {
+    name: string;
+    protected description: string;
+    protected argsShape: {
+        query: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        database: z.ZodString;
+        collection: z.ZodString;
+    };
+    operationType: OperationType;
+    protected execute({ database, collection, query }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult>;
+}
+//# sourceMappingURL=count.d.ts.map

package/dist/cjs/tools/mongodb/read/count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/count.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAmB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,SAAS;;CAQrB,CAAC;AAEF,qBAAa,SAAU,SAAQ,eAAe;IACnC,IAAI,SAAW;IACtB,SAAS,CAAC,WAAW,SAC4G;IACjI,SAAS,CAAC,SAAS;;;;MAGjB;IAEK,aAAa,EAAE,aAAa,CAAU;cAE7B,OAAO,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;CA2BrH"}

package/dist/cjs/tools/mongodb/read/count.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountTool = exports.CountArgs = void 0;
+const mongodbTool_js_1 = require("../mongodbTool.js");
+const zod_1 = require("zod");
+const indexCheck_js_1 = require("../../../helpers/indexCheck.js");
+exports.CountArgs = {
+    query: zod_1.z
+        .object({})
+        .passthrough()
+        .optional()
+        .describe("A filter/query parameter. Allows users to filter the documents to count. Matches the syntax of the filter argument of db.collection.count()."),
+};
+class CountTool extends mongodbTool_js_1.MongoDBToolBase {
+    constructor() {
+        super(...arguments);
+        this.name = "count";
+        this.description = "Gets the number of documents in a MongoDB collection using db.collection.count() and query as an optional filter parameter";
+        this.argsShape = {
+            ...mongodbTool_js_1.DbOperationArgs,
+            ...exports.CountArgs,
+        };
+        this.operationType = "read";
+    }
+    async execute({ database, collection, query }) {
+        const provider = await this.ensureConnected();
+        // Check if count operation uses an index if enabled
+        if (this.config.indexCheck) {
+            await (0, indexCheck_js_1.checkIndexUsage)(provider, database, collection, "count", async () => {
+                return provider.runCommandWithCheck(database, {
+                    explain: {
+                        count: collection,
+                        query,
+                    },
+                    verbosity: "queryPlanner",
+                });
+            });
+        }
+        const count = await provider.count(database, collection, query);
+        return {
+            content: [
+                {
+                    text: `Found ${count} documents in the collection "${collection}"`,
+                    type: "text",
+                },
+            ],
+        };
+    }
+}
+exports.CountTool = CountTool;
+//# sourceMappingURL=count.js.map

package/dist/cjs/tools/mongodb/read/count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.js","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/count.ts"],"names":[],"mappings":";;;AACA,sDAAqE;AAErE,6BAAwB;AACxB,kEAAiE;AAEpD,QAAA,SAAS,GAAG;IACrB,KAAK,EAAE,OAAC;SACH,MAAM,CAAC,EAAE,CAAC;SACV,WAAW,EAAE;SACb,QAAQ,EAAE;SACV,QAAQ,CACL,8IAA8I,CACjJ;CACR,CAAC;AAEF,MAAa,SAAU,SAAQ,gCAAe;IAA9C;;QACW,SAAI,GAAG,OAAO,CAAC;QACZ,gBAAW,GACjB,4HAA4H,CAAC;QACvH,cAAS,GAAG;YAClB,GAAG,gCAAe;YAClB,GAAG,iBAAS;SACf,CAAC;QAEK,kBAAa,GAAkB,MAAM,CAAC;IA6BjD,CAAC;IA3Ba,KAAK,CAAC,OAAO,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAmC;QACpF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;QAE9C,oDAAoD;QACpD,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;YACzB,MAAM,IAAA,+BAAe,EAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,IAAI,EAAE;gBACtE,OAAO,QAAQ,CAAC,mBAAmB,CAAC,QAAQ,EAAE;oBAC1C,OAAO,EAAE;wBACL,KAAK,EAAE,UAAU;wBACjB,KAAK;qBACR;oBACD,SAAS,EAAE,cAAc;iBAC5B,CAAC,CAAC;YACP,CAAC,CAAC,CAAC;QACP,CAAC;QAED,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;QAEhE,OAAO;YACH,OAAO,EAAE;gBACL;oBACI,IAAI,EAAE,SAAS,KAAK,iCAAiC,UAAU,GAAG;oBAClE,IAAI,EAAE,MAAM;iBACf;aACJ;SACJ,CAAC;IACN,CAAC;CACJ;AAtCD,8BAsCC"}

package/dist/cjs/tools/mongodb/read/export.d.ts

@@ -0,0 +1,72 @@
+import z from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type { OperationType, ToolArgs } from "../../tool.js";
+import { MongoDBToolBase } from "../mongodbTool.js";
+export declare class ExportTool extends MongoDBToolBase {
+    name: string;
+    protected description: string;
+    protected argsShape: {
+        exportTitle: z.ZodString;
+        exportTarget: z.ZodArray<z.ZodDiscriminatedUnion<"name", [z.ZodObject<{
+            name: z.ZodLiteral<"find">;
+            arguments: z.ZodObject<{
+                limit: z.ZodOptional<z.ZodNumber>;
+                filter: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+                projection: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+                sort: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodType<import("mongodb").SortDirection, z.ZodTypeDef, import("mongodb").SortDirection>, {}, {}>>;
+            }, "strip", z.ZodTypeAny, {
+                sort?: {} | undefined;
+                filter?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                limit?: number | undefined;
+                projection?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+            }, {
+                sort?: {} | undefined;
+                filter?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                limit?: number | undefined;
+                projection?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            name: "find";
+            arguments: {
+                sort?: {} | undefined;
+                filter?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                limit?: number | undefined;
+                projection?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+            };
+        }, {
+            name: "find";
+            arguments: {
+                sort?: {} | undefined;
+                filter?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+                limit?: number | undefined;
+                projection?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+            };
+        }>, z.ZodObject<{
+            name: z.ZodLiteral<"aggregate">;
+            arguments: z.ZodObject<{
+                pipeline: z.ZodArray<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                pipeline: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            }, {
+                pipeline: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            name: "aggregate";
+            arguments: {
+                pipeline: z.objectOutputType<{}, z.ZodTypeAny, "passthrough">[];
+            };
+        }, {
+            name: "aggregate";
+            arguments: {
+                pipeline: z.objectInputType<{}, z.ZodTypeAny, "passthrough">[];
+            };
+        }>]>, "many">;
+        jsonExportFormat: z.ZodDefault<z.ZodEnum<["relaxed", "canonical"]>>;
+        database: z.ZodString;
+        collection: z.ZodString;
+    };
+    operationType: OperationType;
+    protected execute({ database, collection, jsonExportFormat, exportTitle, exportTarget: target, }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult>;
+    private isServerRunningLocally;
+}
+//# sourceMappingURL=export.d.ts.map

package/dist/cjs/tools/mongodb/read/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/export.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAmB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAKrE,qBAAa,UAAW,SAAQ,eAAe;IACpC,IAAI,SAAY;IACvB,SAAS,CAAC,WAAW,SAA0E;IAC/F,SAAS,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmCjB;IACK,aAAa,EAAE,aAAa,CAAU;cAE7B,OAAO,CAAC,EACpB,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,WAAW,EACX,YAAY,EAAE,MAAM,GACvB,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;IAoE5D,OAAO,CAAC,sBAAsB;CAGjC"}

package/dist/cjs/tools/mongodb/read/export.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportTool = void 0;
+const zod_1 = __importDefault(require("zod"));
+const bson_1 = require("bson");
+const mongodbTool_js_1 = require("../mongodbTool.js");
+const find_js_1 = require("./find.js");
+const exportsManager_js_1 = require("../../../common/exportsManager.js");
+const aggregate_js_1 = require("./aggregate.js");
+class ExportTool extends mongodbTool_js_1.MongoDBToolBase {
+    constructor() {
+        super(...arguments);
+        this.name = "export";
+        this.description = "Export a query or aggregation results in the specified EJSON format.";
+        this.argsShape = {
+            ...mongodbTool_js_1.DbOperationArgs,
+            exportTitle: zod_1.default.string().describe("A short description to uniquely identify the export."),
+            exportTarget: zod_1.default
+                .array(zod_1.default.discriminatedUnion("name", [
+                zod_1.default.object({
+                    name: zod_1.default
+                        .literal("find")
+                        .describe("The literal name 'find' to represent a find cursor as target."),
+                    arguments: zod_1.default
+                        .object({
+                        ...find_js_1.FindArgs,
+                        limit: find_js_1.FindArgs.limit.removeDefault(),
+                    })
+                        .describe("The arguments for 'find' operation."),
+                }),
+                zod_1.default.object({
+                    name: zod_1.default
+                        .literal("aggregate")
+                        .describe("The literal name 'aggregate' to represent an aggregation cursor as target."),
+                    arguments: zod_1.default.object(aggregate_js_1.AggregateArgs).describe("The arguments for 'aggregate' operation."),
+                }),
+            ]))
+                .describe("The export target along with its arguments."),
+            jsonExportFormat: exportsManager_js_1.jsonExportFormat
+                .default("relaxed")
+                .describe([
+                "The format to be used when exporting collection data as EJSON with default being relaxed.",
+                "relaxed: A string format that emphasizes readability and interoperability at the expense of type preservation. That is, conversion from relaxed format to BSON can lose type information.",
+                "canonical: A string format that emphasizes type preservation at the expense of readability and interoperability. That is, conversion from canonical to BSON will generally preserve type information except in certain specific cases.",
+            ].join("\n")),
+        };
+        this.operationType = "read";
+    }
+    async execute({ database, collection, jsonExportFormat, exportTitle, exportTarget: target, }) {
+        const provider = await this.ensureConnected();
+        const exportTarget = target[0];
+        if (!exportTarget) {
+            throw new Error("Export target not provided. Expected one of the following: `aggregate`, `find`");
+        }
+        let cursor;
+        if (exportTarget.name === "find") {
+            const { filter, projection, sort, limit } = exportTarget.arguments;
+            cursor = provider.find(database, collection, filter ?? {}, {
+                projection,
+                sort,
+                limit,
+                promoteValues: false,
+                bsonRegExp: true,
+            });
+        }
+        else {
+            const { pipeline } = exportTarget.arguments;
+            cursor = provider.aggregate(database, collection, pipeline, {
+                promoteValues: false,
+                bsonRegExp: true,
+                allowDiskUse: true,
+            });
+        }
+        const exportName = `${database}.${collection}.${new bson_1.ObjectId().toString()}.json`;
+        const { exportURI, exportPath } = await this.session.exportsManager.createJSONExport({
+            input: cursor,
+            exportName,
+            exportTitle: exportTitle ||
+                `Export for namespace ${database}.${collection} requested on ${new Date().toLocaleString()}`,
+            jsonExportFormat,
+        });
+        const toolCallContent = [
+            // Not all the clients as of this commit understands how to
+            // parse a resource_link so we provide a text result for them to
+            // understand what to do with the result.
+            {
+                type: "text",
+                text: `Data for namespace ${database}.${collection} is being exported and will be made available under resource URI - "${exportURI}".`,
+            },
+            {
+                type: "resource_link",
+                name: exportName,
+                uri: exportURI,
+                description: "Resource URI for fetching exported data once it is ready.",
+                mimeType: "application/json",
+            },
+        ];
+        // This special case is to make it easier to work with exported data for
+        // clients that still cannot reference resources (Cursor).
+        // More information here: https://jira.mongodb.org/browse/MCP-104
+        if (this.isServerRunningLocally()) {
+            toolCallContent.push({
+                type: "text",
+                text: `Optionally, when the export is finished, the exported data can also be accessed under path - "${exportPath}"`,
+            });
+        }
+        return {
+            content: toolCallContent,
+        };
+    }
+    isServerRunningLocally() {
+        return this.config.transport === "stdio" || ["127.0.0.1", "localhost"].includes(this.config.httpHost);
+    }
+}
+exports.ExportTool = ExportTool;
+//# sourceMappingURL=export.js.map

package/dist/cjs/tools/mongodb/read/export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.js","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/export.ts"],"names":[],"mappings":"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"}

package/dist/cjs/tools/mongodb/read/find.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { MongoDBToolBase } from "../mongodbTool.js";
+import type { ToolArgs, OperationType } from "../../tool.js";
+import type { SortDirection } from "mongodb";
+export declare const FindArgs: {
+    filter: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    projection: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    sort: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodType<SortDirection, z.ZodTypeDef, SortDirection>, {}, {}>>;
+};
+export declare class FindTool extends MongoDBToolBase {
+    name: string;
+    protected description: string;
+    protected argsShape: {
+        filter: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        projection: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        sort: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodType<SortDirection, z.ZodTypeDef, SortDirection>, {}, {}>>;
+        database: z.ZodString;
+        collection: z.ZodString;
+    };
+    operationType: OperationType;
+    protected execute({ database, collection, filter, projection, limit, sort, }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult>;
+}
+//# sourceMappingURL=find.d.ts.map

package/dist/cjs/tools/mongodb/read/find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/find.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAmB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAI7C,eAAO,MAAM,QAAQ;;;;;CAmBpB,CAAC;AAEF,qBAAa,QAAS,SAAQ,eAAe;IAClC,IAAI,SAAU;IACrB,SAAS,CAAC,WAAW,SAAmD;IACxE,SAAS,CAAC,SAAS;;;;;;;MAGjB;IACK,aAAa,EAAE,aAAa,CAAU;cAE7B,OAAO,CAAC,EACpB,QAAQ,EACR,UAAU,EACV,MAAM,EACN,UAAU,EACV,KAAK,EACL,IAAI,GACP,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,cAAc,CAAC;CAmB/D"}