mongodb-mcp-server 0.2.0 → 0.3.0

package/src/tools/atlas/create/createProject.ts

@@ -1,68 +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 { Group } from "../../../common/atlas/openapi.js";
-
-export class CreateProjectTool extends AtlasToolBase {
-    public name = "atlas-create-project";
-    protected description = "Create a MongoDB Atlas project";
-    public operationType: OperationType = "create";
-    protected argsShape = {
-        projectName: z.string().optional().describe("Name for the new project"),
-        organizationId: z.string().optional().describe("Organization ID for the new project"),
-    };
-
-    protected async execute({ projectName, organizationId }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        let assumedOrg = false;
-
-        if (!projectName) {
-            projectName = "Atlas Project";
-        }
-
-        if (!organizationId) {
-            try {
-                const organizations = await this.session.apiClient.listOrganizations();
-                if (!organizations?.results?.length) {
-                    throw new Error(
-                        "No organizations were found in your MongoDB Atlas account. Please create an organization first."
-                    );
-                }
-                const firstOrg = organizations.results[0];
-                if (!firstOrg?.id) {
-                    throw new Error(
-                        "The first organization found does not have an ID. Please check your Atlas account."
-                    );
-                }
-                organizationId = firstOrg.id;
-                assumedOrg = true;
-            } catch {
-                throw new Error(
-                    "Could not search for organizations in your MongoDB Atlas account, please provide an organization ID or create one first."
-                );
-            }
-        }
-
-        const input = {
-            name: projectName,
-            orgId: organizationId,
-        } as Group;
-
-        const group = await this.session.apiClient.createProject({
-            body: input,
-        });
-
-        if (!group?.id) {
-            throw new Error("Failed to create project");
-        }
-
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Project "${projectName}" created successfully${assumedOrg ? ` (using organizationId ${organizationId}).` : ""}.`,
-                },
-            ],
-        };
-    }
-}

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 {
-    public name = "atlas-inspect-access-list";
-    protected description = "Inspect Ip/CIDR ranges with access to your MongoDB Atlas clusters.";
-    public 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 {
-    public name = "atlas-inspect-cluster";
-    protected description = "Inspect MongoDB Atlas cluster";
-    public 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 {
-    public name = "atlas-list-alerts";
-    protected description = "List MongoDB Atlas alerts";
-    public 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 {
-    public name = "atlas-list-clusters";
-    protected description = "List MongoDB Atlas clusters";
-    public 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 {
-    public name = "atlas-list-db-users";
-    protected description = "List MongoDB Atlas database users";
-    public 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 {
-    public name = "atlas-list-orgs";
-    protected description = "List MongoDB Atlas organizations";
-    public 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 {
-    public name = "atlas-list-projects";
-    protected description = "List MongoDB Atlas projects";
-    public 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/atlas/tools.ts

@@ -1,27 +0,0 @@
-import { ListClustersTool } from "./read/listClusters.js";
-import { ListProjectsTool } from "./read/listProjects.js";
-import { InspectClusterTool } from "./read/inspectCluster.js";
-import { CreateFreeClusterTool } from "./create/createFreeCluster.js";
-import { CreateAccessListTool } from "./create/createAccessList.js";
-import { InspectAccessListTool } from "./read/inspectAccessList.js";
-import { ListDBUsersTool } from "./read/listDBUsers.js";
-import { CreateDBUserTool } from "./create/createDBUser.js";
-import { CreateProjectTool } from "./create/createProject.js";
-import { ListOrganizationsTool } from "./read/listOrgs.js";
-import { ConnectClusterTool } from "./connect/connectCluster.js";
-import { ListAlertsTool } from "./read/listAlerts.js";
-
-export const AtlasTools = [
-    ListClustersTool,
-    ListProjectsTool,
-    InspectClusterTool,
-    CreateFreeClusterTool,
-    CreateAccessListTool,
-    InspectAccessListTool,
-    ListDBUsersTool,
-    CreateDBUserTool,
-    CreateProjectTool,
-    ListOrganizationsTool,
-    ConnectClusterTool,
-    ListAlertsTool,
-];

package/src/tools/mongodb/connect/connect.ts

@@ -1,99 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import assert from "assert";
-import { UserConfig } from "../../../common/config.js";
-import { Telemetry } from "../../../telemetry/telemetry.js";
-import { Session } from "../../../common/session.js";
-import { Server } from "../../../server.js";
-
-const disconnectedSchema = z
-    .object({
-        connectionString: z.string().describe("MongoDB connection string (in the mongodb:// or mongodb+srv:// format)"),
-    })
-    .describe("Options for connecting to MongoDB.");
-
-const connectedSchema = z
-    .object({
-        connectionString: z
-            .string()
-            .optional()
-            .describe("MongoDB connection string to switch to (in the mongodb:// or mongodb+srv:// format)"),
-    })
-    .describe(
-        "Options for switching the current MongoDB connection. If a connection string is not provided, the connection string from the config will be used."
-    );
-
-const connectedName = "switch-connection" as const;
-const disconnectedName = "connect" as const;
-
-const connectedDescription =
-    "Switch to a different MongoDB connection. If the user has configured a connection string or has previously called the connect tool, a connection is already established and there's no need to call this tool unless the user has explicitly requested to switch to a new instance.";
-const disconnectedDescription = "Connect to a MongoDB instance";
-
-export class ConnectTool extends MongoDBToolBase {
-    public name: typeof connectedName | typeof disconnectedName = disconnectedName;
-    protected description: typeof connectedDescription | typeof disconnectedDescription = disconnectedDescription;
-
-    // Here the default is empty just to trigger registration, but we're going to override it with the correct
-    // schema in the register method.
-    protected argsShape = {
-        connectionString: z.string().optional(),
-    };
-
-    public operationType: OperationType = "connect";
-
-    constructor(session: Session, config: UserConfig, telemetry: Telemetry) {
-        super(session, config, telemetry);
-        session.on("disconnect", () => {
-            this.updateMetadata();
-        });
-    }
-
-    protected async execute({ connectionString }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        switch (this.name) {
-            case disconnectedName:
-                assert(connectionString, "Connection string is required");
-                break;
-            case connectedName:
-                connectionString ??= this.config.connectionString;
-                assert(
-                    connectionString,
-                    "Cannot switch to a new connection because no connection string was provided and no default connection string is configured."
-                );
-                break;
-        }
-
-        await this.connectToMongoDB(connectionString);
-        this.updateMetadata();
-        return {
-            content: [{ type: "text", text: "Successfully connected to MongoDB." }],
-        };
-    }
-
-    public register(server: Server): boolean {
-        if (super.register(server)) {
-            this.updateMetadata();
-            return true;
-        }
-
-        return false;
-    }
-
-    private updateMetadata(): void {
-        if (this.config.connectionString || this.session.serviceProvider) {
-            this.update?.({
-                name: connectedName,
-                description: connectedDescription,
-                inputSchema: connectedSchema,
-            });
-        } else {
-            this.update?.({
-                name: disconnectedName,
-                description: disconnectedDescription,
-                inputSchema: disconnectedSchema,
-            });
-        }
-    }
-}

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 {
-    public 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;
-
-    public 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 {
-    public name = "create-index";
-    protected description = "Create an index for a collection";
-    protected argsShape = {
-        ...DbOperationArgs,
-        keys: z.object({}).catchall(z.custom<IndexDirection>()).describe("The index definition"),
-        name: z.string().optional().describe("The name of the index"),
-    };
-
-    public 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",
-                },
-            ],
-        };
-    }
-}