mongodb-mcp-server 0.1.3 → 0.3.0

package/src/tools/atlas/read/inspectAccessList.ts

@@ -1,42 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "../atlasTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-
-export class InspectAccessListTool extends AtlasToolBase {
-    protected name = "atlas-inspect-access-list";
-    protected description = "Inspect Ip/CIDR ranges with access to your MongoDB Atlas clusters.";
-    protected operationType: OperationType = "read";
-    protected argsShape = {
-        projectId: z.string().describe("Atlas project ID"),
-    };
-
-    protected async execute({ projectId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const accessList = await this.session.apiClient.listProjectIpAccessLists({
-            params: {
-                path: {
-                    groupId: projectId,
-                },
-            },
-        });
-
-        if (!accessList?.results?.length) {
-            throw new Error("No access list entries found.");
-        }
-
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `IP ADDRESS | CIDR | COMMENT
-------|------|------
-${(accessList.results || [])
-    .map((entry) => {
-        return `${entry.ipAddress} | ${entry.cidrBlock} | ${entry.comment}`;
-    })
-    .join("\n")}`,
-                },
-            ],
-        };
-    }
-}

package/src/tools/atlas/read/inspectCluster.ts

@@ -1,34 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "../atlasTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import { Cluster, inspectCluster } from "../../../common/atlas/cluster.js";
-
-export class InspectClusterTool extends AtlasToolBase {
-    protected name = "atlas-inspect-cluster";
-    protected description = "Inspect MongoDB Atlas cluster";
-    protected operationType: OperationType = "read";
-    protected argsShape = {
-        projectId: z.string().describe("Atlas project ID"),
-        clusterName: z.string().describe("Atlas cluster name"),
-    };
-
-    protected async execute({ projectId, clusterName }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const cluster = await inspectCluster(this.session.apiClient, projectId, clusterName);
-
-        return this.formatOutput(cluster);
-    }
-
-    private formatOutput(formattedCluster: Cluster): CallToolResult {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Cluster Name | Cluster Type | Tier | State | MongoDB Version | Connection String
-----------------|----------------|----------------|----------------|----------------|----------------
-${formattedCluster.name || "Unknown"} | ${formattedCluster.instanceType} | ${formattedCluster.instanceSize || "N/A"} | ${formattedCluster.state || "UNKNOWN"} | ${formattedCluster.mongoDBVersion || "N/A"} | ${formattedCluster.connectionString || "N/A"}`,
-                },
-            ],
-        };
-    }
-}

package/src/tools/atlas/read/listAlerts.ts

@@ -1,45 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "../atlasTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-
-export class ListAlertsTool extends AtlasToolBase {
-    protected name = "atlas-list-alerts";
-    protected description = "List MongoDB Atlas alerts";
-    protected operationType: OperationType = "read";
-    protected argsShape = {
-        projectId: z.string().describe("Atlas project ID to list alerts for"),
-    };
-
-    protected async execute({ projectId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const data = await this.session.apiClient.listAlerts({
-            params: {
-                path: {
-                    groupId: projectId,
-                },
-            },
-        });
-
-        if (!data?.results?.length) {
-            return { content: [{ type: "text", text: "No alerts found in your MongoDB Atlas project." }] };
-        }
-
-        // Format alerts as a table
-        const output =
-            `Alert ID | Status | Created | Updated | Type | Comment
-----------|---------|----------|----------|------|--------
-` +
-            data.results
-                .map((alert) => {
-                    const created = alert.created ? new Date(alert.created).toLocaleString() : "N/A";
-                    const updated = alert.updated ? new Date(alert.updated).toLocaleString() : "N/A";
-                    const comment = alert.acknowledgementComment ?? "N/A";
-                    return `${alert.id} | ${alert.status} | ${created} | ${updated} | ${alert.eventTypeName} | ${comment}`;
-                })
-                .join("\n");
-
-        return {
-            content: [{ type: "text", text: output }],
-        };
-    }
-}

package/src/tools/atlas/read/listClusters.ts

@@ -1,113 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "../atlasTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import {
-    PaginatedClusterDescription20240805,
-    PaginatedOrgGroupView,
-    Group,
-    PaginatedFlexClusters20241113,
-} from "../../../common/atlas/openapi.js";
-import { formatCluster, formatFlexCluster } from "../../../common/atlas/cluster.js";
-
-export class ListClustersTool extends AtlasToolBase {
-    protected name = "atlas-list-clusters";
-    protected description = "List MongoDB Atlas clusters";
-    protected operationType: OperationType = "read";
-    protected argsShape = {
-        projectId: z.string().describe("Atlas project ID to filter clusters").optional(),
-    };
-
-    protected async execute({ projectId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        if (!projectId) {
-            const data = await this.session.apiClient.listClustersForAllProjects();
-
-            return this.formatAllClustersTable(data);
-        } else {
-            const project = await this.session.apiClient.getProject({
-                params: {
-                    path: {
-                        groupId: projectId,
-                    },
-                },
-            });
-
-            if (!project?.id) {
-                throw new Error(`Project with ID "${projectId}" not found.`);
-            }
-
-            const data = await this.session.apiClient.listClusters({
-                params: {
-                    path: {
-                        groupId: project.id || "",
-                    },
-                },
-            });
-
-            return this.formatClustersTable(project, data);
-        }
-    }
-
-    private formatAllClustersTable(clusters?: PaginatedOrgGroupView): CallToolResult {
-        if (!clusters?.results?.length) {
-            throw new Error("No clusters found.");
-        }
-        const formattedClusters = clusters.results
-            .map((result) => {
-                return (result.clusters || []).map((cluster) => {
-                    return { ...result, ...cluster, clusters: undefined };
-                });
-            })
-            .flat();
-        if (!formattedClusters.length) {
-            throw new Error("No clusters found.");
-        }
-        const rows = formattedClusters
-            .map((cluster) => {
-                return `${cluster.groupName} (${cluster.groupId}) | ${cluster.name}`;
-            })
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Project | Cluster Name
-----------------|----------------
-${rows}`,
-                },
-            ],
-        };
-    }
-
-    private formatClustersTable(
-        project: Group,
-        clusters?: PaginatedClusterDescription20240805,
-        flexClusters?: PaginatedFlexClusters20241113
-    ): CallToolResult {
-        // Check if both traditional clusters and flex clusters are absent
-        if (!clusters?.results?.length && !flexClusters?.results?.length) {
-            throw new Error("No clusters found.");
-        }
-        const formattedClusters = clusters?.results?.map((cluster) => formatCluster(cluster)) || [];
-        const formattedFlexClusters = flexClusters?.results?.map((cluster) => formatFlexCluster(cluster)) || [];
-        const rows = [...formattedClusters, ...formattedFlexClusters]
-            .map((formattedCluster) => {
-                return `${formattedCluster.name || "Unknown"} | ${formattedCluster.instanceType} | ${formattedCluster.instanceSize || "N/A"} | ${formattedCluster.state || "UNKNOWN"} | ${formattedCluster.mongoDBVersion || "N/A"} | ${formattedCluster.connectionString || "N/A"}`;
-            })
-            .join("\n");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Here are your MongoDB Atlas clusters in project "${project.name}" (${project.id}):`,
-                },
-                {
-                    type: "text",
-                    text: `Cluster Name | Cluster Type | Tier | State | MongoDB Version | Connection String
-----------------|----------------|----------------|----------------|----------------|----------------
-${rows}`,
-                },
-            ],
-        };
-    }
-}

package/src/tools/atlas/read/listDBUsers.ts

@@ -1,60 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "../atlasTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import { DatabaseUserRole, UserScope } from "../../../common/atlas/openapi.js";
-
-export class ListDBUsersTool extends AtlasToolBase {
-    protected name = "atlas-list-db-users";
-    protected description = "List MongoDB Atlas database users";
-    protected operationType: OperationType = "read";
-    protected argsShape = {
-        projectId: z.string().describe("Atlas project ID to filter DB users"),
-    };
-
-    protected async execute({ projectId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const data = await this.session.apiClient.listDatabaseUsers({
-            params: {
-                path: {
-                    groupId: projectId,
-                },
-            },
-        });
-
-        if (!data?.results?.length) {
-            throw new Error("No database users found.");
-        }
-
-        const output =
-            `Username | Roles | Scopes
-----------------|----------------|----------------
-` +
-            data.results
-                .map((user) => {
-                    return `${user.username} | ${formatRoles(user.roles)} | ${formatScopes(user.scopes)}`;
-                })
-                .join("\n");
-        return {
-            content: [{ type: "text", text: output }],
-        };
-    }
-}
-
-function formatRoles(roles?: DatabaseUserRole[]) {
-    if (!roles?.length) {
-        return "N/A";
-    }
-    return roles
-        .map(
-            (role) =>
-                `${role.roleName}${role.databaseName ? `@${role.databaseName}${role.collectionName ? `:${role.collectionName}` : ""}` : ""}`
-        )
-        .join(", ");
-}
-
-function formatScopes(scopes?: UserScope[]) {
-    if (!scopes?.length) {
-        return "All";
-    }
-    return scopes.map((scope) => `${scope.type}:${scope.name}`).join(", ");
-}

package/src/tools/atlas/read/listOrgs.ts

@@ -1,32 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "../atlasTool.js";
-import { OperationType } from "../../tool.js";
-
-export class ListOrganizationsTool extends AtlasToolBase {
-    protected name = "atlas-list-orgs";
-    protected description = "List MongoDB Atlas organizations";
-    protected operationType: OperationType = "read";
-    protected argsShape = {};
-
-    protected async execute(): Promise<CallToolResult> {
-        const data = await this.session.apiClient.listOrganizations();
-
-        if (!data?.results?.length) {
-            throw new Error("No projects found in your MongoDB Atlas account.");
-        }
-
-        // Format projects as a table
-        const output =
-            `Organization Name | Organization ID
-----------------| ----------------
-` +
-            data.results
-                .map((org) => {
-                    return `${org.name} | ${org.id}`;
-                })
-                .join("\n");
-        return {
-            content: [{ type: "text", text: output }],
-        };
-    }
-}

package/src/tools/atlas/read/listProjects.ts

@@ -1,56 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { AtlasToolBase } from "../atlasTool.js";
-import { OperationType } from "../../tool.js";
-import { z } from "zod";
-import { ToolArgs } from "../../tool.js";
-
-export class ListProjectsTool extends AtlasToolBase {
-    protected name = "atlas-list-projects";
-    protected description = "List MongoDB Atlas projects";
-    protected operationType: OperationType = "read";
-    protected argsShape = {
-        orgId: z.string().describe("Atlas organization ID to filter projects").optional(),
-    };
-
-    protected async execute({ orgId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const orgData = await this.session.apiClient.listOrganizations();
-
-        if (!orgData?.results?.length) {
-            throw new Error("No organizations found in your MongoDB Atlas account.");
-        }
-
-        const orgs: Record<string, string> = orgData.results
-            .map((org) => [org.id || "", org.name])
-            .filter(([id]) => id)
-            .reduce((acc, [id, name]) => ({ ...acc, [id as string]: name }), {});
-
-        const data = orgId
-            ? await this.session.apiClient.listOrganizationProjects({
-                  params: {
-                      path: {
-                          orgId,
-                      },
-                  },
-              })
-            : await this.session.apiClient.listProjects();
-
-        if (!data?.results?.length) {
-            throw new Error("No projects found in your MongoDB Atlas account.");
-        }
-
-        // Format projects as a table
-        const rows = data.results
-            .map((project) => {
-                const createdAt = project.created ? new Date(project.created).toLocaleString() : "N/A";
-                const orgName = orgs[project.orgId] ?? "N/A";
-                return `${project.name} | ${project.id} | ${orgName} | ${project.orgId} | ${createdAt}`;
-            })
-            .join("\n");
-        const formattedProjects = `Project Name | Project ID | Organization Name | Organization ID | Created At
-----------------| ----------------| ----------------| ----------------| ----------------
-${rows}`;
-        return {
-            content: [{ type: "text", text: formattedProjects }],
-        };
-    }
-}

package/src/tools/mongodb/create/createCollection.ts

@@ -1,26 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { OperationType, ToolArgs } from "../../tool.js";
-
-export class CreateCollectionTool extends MongoDBToolBase {
-    protected name = "create-collection";
-    protected description =
-        "Creates a new collection in a database. If the database doesn't exist, it will be created automatically.";
-    protected argsShape = DbOperationArgs;
-
-    protected operationType: OperationType = "create";
-
-    protected async execute({ collection, database }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-        await provider.createCollection(database, collection);
-
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Collection "${collection}" created in database "${database}".`,
-                },
-            ],
-        };
-    }
-}

package/src/tools/mongodb/create/createIndex.ts

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import { IndexDirection } from "mongodb";
-
-export class CreateIndexTool extends MongoDBToolBase {
-    protected name = "create-index";
-    protected description = "Create an index for a collection";
-    protected argsShape = {
-        ...DbOperationArgs,
-        keys: z.record(z.string(), z.custom<IndexDirection>()).describe("The index definition"),
-        name: z.string().optional().describe("The name of the index"),
-    };
-
-    protected operationType: OperationType = "create";
-
-    protected async execute({
-        database,
-        collection,
-        keys,
-        name,
-    }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-        const indexes = await provider.createIndexes(database, collection, [
-            {
-                key: keys,
-                name,
-            },
-        ]);
-
-        return {
-            content: [
-                {
-                    text: `Created the index "${indexes[0]}" on collection "${collection}" in database "${database}"`,
-                    type: "text",
-                },
-            ],
-        };
-    }
-}

package/src/tools/mongodb/create/insertMany.ts

@@ -1,40 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-
-export class InsertManyTool extends MongoDBToolBase {
-    protected name = "insert-many";
-    protected description = "Insert an array of documents into a MongoDB collection";
-    protected argsShape = {
-        ...DbOperationArgs,
-        documents: z
-            .array(z.record(z.string(), z.unknown()).describe("An individual MongoDB document"))
-            .describe(
-                "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany()"
-            ),
-    };
-    protected operationType: OperationType = "create";
-
-    protected async execute({
-        database,
-        collection,
-        documents,
-    }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-        const result = await provider.insertMany(database, collection, documents);
-
-        return {
-            content: [
-                {
-                    text: `Inserted \`${result.insertedCount}\` document(s) into collection "${collection}"`,
-                    type: "text",
-                },
-                {
-                    text: `Inserted IDs: ${Object.values(result.insertedIds).join(", ")}`,
-                    type: "text",
-                },
-            ],
-        };
-    }
-}

package/src/tools/mongodb/delete/deleteMany.ts

@@ -1,57 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import { checkIndexUsage } from "../../../helpers/indexCheck.js";
-
-export class DeleteManyTool extends MongoDBToolBase {
-    protected name = "delete-many";
-    protected description = "Removes all documents that match the filter from a MongoDB collection";
-    protected argsShape = {
-        ...DbOperationArgs,
-        filter: z
-            .record(z.string(), z.unknown())
-            .optional()
-            .describe(
-                "The query filter, specifying the deletion criteria. Matches the syntax of the filter argument of db.collection.deleteMany()"
-            ),
-    };
-    protected operationType: OperationType = "delete";
-
-    protected async execute({
-        database,
-        collection,
-        filter,
-    }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-
-        // Check if delete operation uses an index if enabled
-        if (this.config.indexCheck) {
-            await checkIndexUsage(provider, database, collection, "deleteMany", async () => {
-                return provider.runCommandWithCheck(database, {
-                    explain: {
-                        delete: collection,
-                        deletes: [
-                            {
-                                q: filter || {},
-                                limit: 0, // 0 means delete all matching documents
-                            },
-                        ],
-                    },
-                    verbosity: "queryPlanner",
-                });
-            });
-        }
-
-        const result = await provider.deleteMany(database, collection, filter);
-
-        return {
-            content: [
-                {
-                    text: `Deleted \`${result.deletedCount}\` document(s) from collection "${collection}"`,
-                    type: "text",
-                },
-            ],
-        };
-    }
-}

package/src/tools/mongodb/delete/dropCollection.ts

@@ -1,27 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-
-export class DropCollectionTool extends MongoDBToolBase {
-    protected name = "drop-collection";
-    protected description =
-        "Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection.";
-    protected argsShape = {
-        ...DbOperationArgs,
-    };
-    protected operationType: OperationType = "delete";
-
-    protected async execute({ database, collection }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-        const result = await provider.dropCollection(database, collection);
-
-        return {
-            content: [
-                {
-                    text: `${result ? "Successfully dropped" : "Failed to drop"} collection "${collection}" from database "${database}"`,
-                    type: "text",
-                },
-            ],
-        };
-    }
-}

package/src/tools/mongodb/delete/dropDatabase.ts

@@ -1,26 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-
-export class DropDatabaseTool extends MongoDBToolBase {
-    protected name = "drop-database";
-    protected description = "Removes the specified database, deleting the associated data files";
-    protected argsShape = {
-        database: DbOperationArgs.database,
-    };
-    protected operationType: OperationType = "delete";
-
-    protected async execute({ database }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-        const result = await provider.dropDatabase(database);
-
-        return {
-            content: [
-                {
-                    text: `${result.ok ? "Successfully dropped" : "Failed to drop"} database "${database}"`,
-                    type: "text",
-                },
-            ],
-        };
-    }
-}

package/src/tools/mongodb/metadata/collectionSchema.ts

@@ -1,43 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import { getSimplifiedSchema } from "mongodb-schema";
-
-export class CollectionSchemaTool extends MongoDBToolBase {
-    protected name = "collection-schema";
-    protected description = "Describe the schema for a collection";
-    protected argsShape = DbOperationArgs;
-
-    protected operationType: OperationType = "metadata";
-
-    protected async execute({ database, collection }: ToolArgs<typeof DbOperationArgs>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-        const documents = await provider.find(database, collection, {}, { limit: 5 }).toArray();
-        const schema = await getSimplifiedSchema(documents);
-
-        const fieldsCount = Object.entries(schema).length;
-        if (fieldsCount === 0) {
-            return {
-                content: [
-                    {
-                        text: `Could not deduce the schema for "${database}.${collection}". This may be because it doesn't exist or is empty.`,
-                        type: "text",
-                    },
-                ],
-            };
-        }
-
-        return {
-            content: [
-                {
-                    text: `Found ${fieldsCount} fields in the schema for "${database}.${collection}"`,
-                    type: "text",
-                },
-                {
-                    text: JSON.stringify(schema),
-                    type: "text",
-                },
-            ],
-        };
-    }
-}