mongodb-mcp-server 0.2.0 → 0.3.0

package/scripts/accuracy/generateTestSummary.ts

@@ -1,335 +0,0 @@
-import path from "path";
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { getAccuracyResultStorage } from "../../tests/accuracy/sdk/accuracyResultStorage/getAccuracyResultStorage.js";
-import {
-    AccuracyResult,
-    AccuracyRunStatuses,
-    ExpectedToolCall,
-    LLMToolCall,
-    ModelResponse,
-} from "../../tests/accuracy/sdk/accuracyResultStorage/resultStorage.js";
-import { getCommitSHA } from "../../tests/accuracy/sdk/gitInfo.js";
-import {
-    HTML_TEST_SUMMARY_FILE,
-    HTML_TESTS_SUMMARY_TEMPLATE,
-    MARKDOWN_TEST_BRIEF_FILE,
-} from "../../tests/accuracy/sdk/constants.js";
-
-type ComparableAccuracyResult = Omit<AccuracyResult, "promptResults"> & {
-    promptAndModelResponses: PromptAndModelResponse[];
-};
-
-interface PromptAndModelResponse extends ModelResponse {
-    prompt: string;
-    expectedToolCalls: ExpectedToolCall[];
-    baselineToolAccuracy?: number;
-}
-
-interface BaselineRunInfo {
-    commitSHA: string;
-    accuracyRunId: string;
-    accuracyRunStatus: AccuracyRunStatuses;
-    createdOn: string;
-}
-
-function populateTemplate(template: string, data: Record<string, string>): string {
-    return template.replace(/\{\{(\w+)\}\}/g, (_, key: string) => data[key] ?? "");
-}
-
-function formatRunStatus(status: AccuracyRunStatuses) {
-    const statusClasses = ["chip", "run-status"];
-    if (status === "done") {
-        statusClasses.push("perfect");
-    } else if (status === "in-progress" || status === "failed") {
-        statusClasses.push("poor");
-    }
-    return `<span class="${statusClasses.join(" ")}">${status}</span>`;
-}
-
-function formatAccuracy(accuracy: number): string {
-    return (accuracy * 100).toFixed(1) + "%";
-}
-
-function getAccuracyClass(accuracy: number): string {
-    if (accuracy === 1) return "chip perfect";
-    if (accuracy >= 0.75) return "chip good";
-    return "chip poor";
-}
-
-function formatToolCallsWithTooltip(toolCalls: ExpectedToolCall[] | LLMToolCall[]): string {
-    return toolCalls
-        .map((call) => {
-            const params = JSON.stringify(call.parameters, null, 2);
-            return `<span class="tool-call" title="${params.replace(/"/g, "&quot;")}">${call.toolName}</span>`;
-        })
-        .join(", ");
-}
-
-function formatTokenUsage(tokensUsage: {
-    promptTokens?: number;
-    completionTokens?: number;
-    totalTokens?: number;
-}): string {
-    const total = tokensUsage.totalTokens || "-";
-    const prompt = tokensUsage.promptTokens || "-";
-    const completion = tokensUsage.completionTokens || "-";
-
-    const tooltip = [`Prompt: ${prompt}`, `Completion: ${completion}`, `Total: ${total}`].join("\n");
-    return `<span class="tokens-usage" title="${tooltip}">${total}</span>`;
-}
-
-function formatMessages(messages: Array<Record<string, unknown>>): string {
-    return messages.map((msg) => JSON.stringify(msg, null, 2)).join("\n\n");
-}
-
-function formatCurrentAccuracy(response: PromptAndModelResponse): string {
-    const currentAccuracyText = formatAccuracy(response.toolCallingAccuracy);
-    const comparisonClass = getAccuracyClass(response.toolCallingAccuracy);
-    let comparisonIcon = "";
-
-    if (typeof response.baselineToolAccuracy === "number") {
-        if (response.toolCallingAccuracy > response.baselineToolAccuracy) {
-            comparisonIcon = " ↗";
-        } else if (response.toolCallingAccuracy < response.baselineToolAccuracy) {
-            comparisonIcon = " ↘";
-        } else {
-            comparisonIcon = " →";
-        }
-    }
-
-    return `<span class="${comparisonClass}">${currentAccuracyText}${comparisonIcon}</span>`;
-}
-
-function formatBaselineAccuracy(response: PromptAndModelResponse): string {
-    if (response.baselineToolAccuracy === null || response.baselineToolAccuracy === undefined) {
-        return '<span class="accuracy-comparison">N/A</span>';
-    }
-    return `<span class="accuracy-comparison">${formatAccuracy(response.baselineToolAccuracy)}</span>`;
-}
-
-function getTestSummary(comparableResult: ComparableAccuracyResult) {
-    const responses = comparableResult.promptAndModelResponses;
-    return {
-        totalPrompts: new Set(responses.map((r) => r.prompt)).size,
-        totalModels: new Set(responses.map((r) => `${r.provider} ${r.requestedModel}`)).size,
-        responsesWithZeroAccuracy: responses.filter((r) => r.toolCallingAccuracy === 0),
-        responsesWith75Accuracy: responses.filter((r) => r.toolCallingAccuracy === 0.75),
-        responsesWith100Accuracy: responses.filter((r) => r.toolCallingAccuracy === 1),
-        averageAccuracy:
-            responses.length > 0 ? responses.reduce((sum, r) => sum + r.toolCallingAccuracy, 0) / responses.length : 0,
-        responsesImproved: responses.filter(
-            (r) => typeof r.baselineToolAccuracy === "number" && r.toolCallingAccuracy > r.baselineToolAccuracy
-        ).length,
-        responsesRegressed: responses.filter(
-            (r) => typeof r.baselineToolAccuracy === "number" && r.toolCallingAccuracy < r.baselineToolAccuracy
-        ).length,
-        reportGeneratedOn: new Date().toLocaleString(),
-        resultCreatedOn: new Date(comparableResult.createdOn).toLocaleString(),
-    };
-}
-
-async function generateHtmlReport(
-    comparableResult: ComparableAccuracyResult,
-    testSummary: ReturnType<typeof getTestSummary>,
-    baselineInfo: BaselineRunInfo | null
-): Promise<string> {
-    const responses = comparableResult.promptAndModelResponses;
-    const tableRows = responses
-        .map(
-            (response, index) => `
-            <tr class="test-row" onclick="toggleDetails(${index})">
-                <td class="prompt-cell">
-                    <span class="expand-indicator" id="indicator-${index}">▶</span>
-                    ${response.prompt}
-                </td>
-                <td class="model-cell">${response.provider} - ${response.requestedModel}</td>
-                <td class="tool-calls-cell">${formatToolCallsWithTooltip(response.expectedToolCalls)}</td>
-                <td class="tool-calls-cell">${formatToolCallsWithTooltip(response.llmToolCalls)}</td>
-                <td class="accuracy-cell">${formatCurrentAccuracy(response)}</td>
-                <td class="baseline-accuracy-cell">${formatBaselineAccuracy(response)}</td>
-                <td class="response-time-cell">${response.llmResponseTime.toFixed(2)}</td>
-                <td class="tokens-cell">${formatTokenUsage(response.tokensUsed || {})}</td>
-            </tr>
-            <tr class="details-row" id="details-${index}">
-                <td colspan="8">
-                    <div class="details-content">
-                        <div class="conversation-section">
-                            <h4>🤖 LLM Response</h4>
-                            <div class="conversation-content">${response.text || "N/A"}</div>
-                        </div>
-                        <div class="conversation-section">
-                            <h4>💬 Conversation Messages</h4>
-                            <div class="conversation-content">${formatMessages(response.messages || [])}</div>
-                        </div>
-                    </div>
-                </td>
-            </tr>
-        `
-        )
-        .join("");
-
-    const template = await readFile(HTML_TESTS_SUMMARY_TEMPLATE, "utf8");
-    return populateTemplate(template, {
-        commitSHA: comparableResult.commitSHA,
-        accuracyRunId: comparableResult.runId,
-        accuracyRunStatus: formatRunStatus(comparableResult.runStatus),
-        reportGeneratedOn: testSummary.reportGeneratedOn,
-        createdOn: testSummary.resultCreatedOn,
-        totalPrompts: String(testSummary.totalPrompts),
-        totalModels: String(testSummary.totalModels),
-        responsesWithZeroAccuracy: String(testSummary.responsesWithZeroAccuracy.length),
-        averageAccuracy: formatAccuracy(testSummary.averageAccuracy),
-        baselineCommitSHA: baselineInfo?.commitSHA || "-",
-        baselineAccuracyRunId: baselineInfo?.accuracyRunId || "-",
-        baselineAccuracyRunStatus: baselineInfo?.accuracyRunStatus
-            ? formatRunStatus(baselineInfo?.accuracyRunStatus)
-            : "-",
-        baselineCreatedOn: baselineInfo?.createdOn || "-",
-        responsesImproved: baselineInfo ? String(testSummary.responsesImproved) : "-",
-        responsesRegressed: baselineInfo ? String(testSummary.responsesRegressed) : "-",
-        tableRows,
-    });
-}
-
-function generateMarkdownBrief(
-    comparableResult: ComparableAccuracyResult,
-    testSummary: ReturnType<typeof getTestSummary>,
-    baselineInfo: BaselineRunInfo | null
-): string {
-    const markdownTexts = [
-        "# 📊 Accuracy Test Results",
-        "## 📈 Summary",
-        "| Metric | Value |",
-        "|--------|-------|",
-        `| **Commit SHA** | \`${comparableResult.commitSHA}\` |`,
-        `| **Run ID** | \`${comparableResult.runId}\` |`,
-        `| **Status** | ${comparableResult.runStatus} |`,
-        `| **Total Prompts Evaluated** | ${testSummary.totalPrompts} |`,
-        `| **Models Tested** | ${testSummary.totalModels} |`,
-        `| **Average Accuracy** | ${formatAccuracy(testSummary.averageAccuracy)} |`,
-        `| **Responses with 0% Accuracy** | ${testSummary.responsesWithZeroAccuracy.length} |`,
-        `| **Responses with 75% Accuracy** | ${testSummary.responsesWith75Accuracy.length} |`,
-        `| **Responses with 100% Accuracy** | ${testSummary.responsesWith100Accuracy.length} |`,
-        "",
-    ];
-
-    if (baselineInfo) {
-        markdownTexts.push(
-            ...[
-                "## 📊 Baseline Comparison",
-                "|--------|-------|",
-                `| **Baseline Commit** | \`${baselineInfo.commitSHA}\` |`,
-                `| **Baseline Run ID** | \`${baselineInfo.accuracyRunId}\` |`,
-                `| **Baseline Run Status** | \`${baselineInfo.accuracyRunStatus}\` |`,
-                `| **Responses Improved** | ${testSummary.responsesImproved} |`,
-                `| **Responses Regressed** | ${testSummary.responsesRegressed} |`,
-                "",
-            ]
-        );
-    }
-
-    const { GITHUB_SERVER_URL, GITHUB_REPOSITORY, GITHUB_RUN_ID } = process.env;
-    const githubRunUrl =
-        GITHUB_SERVER_URL && GITHUB_REPOSITORY && GITHUB_RUN_ID
-            ? `${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}/actions/runs/${GITHUB_RUN_ID}`
-            : null;
-
-    const reportLinkText = githubRunUrl
-        ? `📎 **[Download Full HTML Report](${githubRunUrl})** - Look for the \`accuracy-test-summary\` artifact for detailed results.`
-        : `📎 **Full HTML Report**: \`${HTML_TEST_SUMMARY_FILE}\``;
-
-    markdownTexts.push(...["---", reportLinkText, "", `*Report generated on: ${testSummary.reportGeneratedOn}*`]);
-
-    return markdownTexts.join("\n");
-}
-
-async function generateTestSummary() {
-    const storage = getAccuracyResultStorage();
-    try {
-        const baselineCommit = process.env.MDB_ACCURACY_BASELINE_COMMIT;
-        const accuracyRunCommit = await getCommitSHA();
-        const accuracyRunId = process.env.MDB_ACCURACY_RUN_ID;
-
-        if (!accuracyRunCommit) {
-            throw new Error("Cannot generate summary without accuracyRunCommit");
-        }
-
-        const accuracyRunResult = await storage.getAccuracyResult(accuracyRunCommit, accuracyRunId);
-        if (!accuracyRunResult) {
-            throw new Error(
-                `No accuracy run result found for commitSHA - ${accuracyRunCommit}, runId - ${accuracyRunId}`
-            );
-        }
-
-        const baselineAccuracyRunResult = baselineCommit ? await storage.getAccuracyResult(baselineCommit) : null;
-        const baselineInfo: BaselineRunInfo | null =
-            baselineCommit && baselineAccuracyRunResult
-                ? {
-                      commitSHA: baselineCommit,
-                      accuracyRunId: baselineAccuracyRunResult.runId,
-                      accuracyRunStatus: baselineAccuracyRunResult.runStatus,
-                      createdOn: new Date(baselineAccuracyRunResult.createdOn).toLocaleString(),
-                  }
-                : null;
-
-        const comparableAccuracyResult: ComparableAccuracyResult = {
-            ...accuracyRunResult,
-            promptAndModelResponses: accuracyRunResult.promptResults.flatMap<PromptAndModelResponse>(
-                (currentPromptResult) => {
-                    const baselinePromptResult = baselineAccuracyRunResult?.promptResults.find((baselineResult) => {
-                        return baselineResult.prompt === currentPromptResult.prompt;
-                    });
-
-                    return currentPromptResult.modelResponses.map<PromptAndModelResponse>((currentModelResponse) => {
-                        const baselineModelResponse = baselinePromptResult?.modelResponses.find(
-                            (baselineModelResponse) => {
-                                return (
-                                    baselineModelResponse.provider === currentModelResponse.provider &&
-                                    baselineModelResponse.requestedModel === currentModelResponse.requestedModel
-                                );
-                            }
-                        );
-                        return {
-                            ...currentModelResponse,
-                            prompt: currentPromptResult.prompt,
-                            expectedToolCalls: currentPromptResult.expectedToolCalls,
-                            baselineToolAccuracy: baselineModelResponse?.toolCallingAccuracy,
-                        };
-                    });
-                }
-            ),
-        };
-
-        // Ensure that our writable path actually exist.
-        await mkdir(path.dirname(HTML_TEST_SUMMARY_FILE), { recursive: true });
-
-        console.log(`\n📊 Generating test summary for accuracy run: ${accuracyRunId}\n`);
-        const testSummary = getTestSummary(comparableAccuracyResult);
-
-        const htmlReport = await generateHtmlReport(comparableAccuracyResult, testSummary, baselineInfo);
-        await writeFile(HTML_TEST_SUMMARY_FILE, htmlReport, "utf8");
-        console.log(`✅ HTML report generated: ${HTML_TEST_SUMMARY_FILE}`);
-
-        const markdownBrief = generateMarkdownBrief(comparableAccuracyResult, testSummary, baselineInfo);
-        await writeFile(MARKDOWN_TEST_BRIEF_FILE, markdownBrief, "utf8");
-        console.log(`✅ Markdown brief generated: ${MARKDOWN_TEST_BRIEF_FILE}`);
-
-        console.log(`\n📈 Summary:`);
-        console.log(`   Total prompts evaluated: ${testSummary.totalPrompts}`);
-        console.log(`   Models tested: ${testSummary.totalModels}`);
-        console.log(`   Responses with 0% accuracy: ${testSummary.responsesWithZeroAccuracy.length}`);
-
-        if (baselineCommit) {
-            console.log(`   Baseline commit: ${baselineCommit}`);
-            console.log(`   Responses improved vs baseline: ${testSummary.responsesImproved}`);
-            console.log(`   Responses regressed vs baseline: ${testSummary.responsesRegressed}`);
-        }
-    } catch (error) {
-        console.error("Error generating test summary:", error);
-        process.exit(1);
-    } finally {
-        await storage.close();
-    }
-}
-
-void generateTestSummary();

package/scripts/accuracy/runAccuracyTests.sh

@@ -1,45 +0,0 @@
-#!/bin/sh
-# Variables necessary for the accuracy test runs
-export MDB_ACCURACY_RUN_ID=$(npx uuid v4)
-
-# For providing access tokens for different LLM providers
-# export MDB_OPEN_AI_API_KEY=""
-# export MDB_GEMINI_API_KEY=""
-# export MDB_AZURE_OPEN_AI_API_KEY=""
-# export MDB_AZURE_OPEN_AI_API_URL=""
-
-# For providing a mongodb based storage to store accuracy result
-# export MDB_ACCURACY_MDB_URL=""
-# export MDB_ACCURACY_MDB_DB=""
-# export MDB_ACCURACY_MDB_COLLECTION=""
-
-# By default we run all the tests under tests/accuracy folder unless a path is
-# specified in the command line. Such as:
-# npm run test:accuracy -- tests/accuracy/some-test.test.ts
-echo "Running accuracy tests with MDB_ACCURACY_RUN_ID '$MDB_ACCURACY_RUN_ID'"
-vitest --config vitest.config.ts --project=accuracy --coverage=false --run "$@"
-
-# Preserving the exit code from test run to correctly notify in the CI
-# environments when the tests fail.
-TEST_EXIT_CODE=$?
-
-# Each test run submits an accuracy result with the accuracyRunStatus:
-# "in-progress". When all the tests are done and jest exits with an exit code of
-# 0, we can safely mark accuracy run as finished otherwise failed.
-
-# This "outside-the-test-status-update" is arising out of the fact that each
-# test suite stores their own accuracy run data in the storage and this setup
-# might lead to data inconsistency when the tests fail. To overcome that each
-# accuracy result entry has a status which by default is "in-progress" and is
-# updated when the tests either pass (all our accuracy tests are supposed to
-# pass unless some errors occurs during the test runs), or fail.
-
-# This is necessary when comparing one accuracy run with another as we wouldn't
-# want to compare against an incomplete run.
-export MDB_ACCURACY_RUN_STATUS=$([ $TEST_EXIT_CODE -eq 0 ] && echo "done" || echo "failed")
-npx tsx scripts/accuracy/updateAccuracyRunStatus.ts || echo "Warning: Failed to update accuracy run status to '$MDB_ACCURACY_RUN_STATUS'"
-
-# This is optional but we do it anyways to generate a readable summary of report.
-npx tsx scripts/accuracy/generateTestSummary.ts || echo "Warning: Failed to generate test summary HTML report"
-
-exit $TEST_EXIT_CODE

package/scripts/accuracy/updateAccuracyRunStatus.ts

@@ -1,21 +0,0 @@
-import { getAccuracyResultStorage } from "../../tests/accuracy/sdk/accuracyResultStorage/getAccuracyResultStorage.js";
-import { AccuracyRunStatus } from "../../tests/accuracy/sdk/accuracyResultStorage/resultStorage.js";
-import { getCommitSHA } from "../../tests/accuracy/sdk/gitInfo.js";
-
-const envAccuracyRunId = process.env.MDB_ACCURACY_RUN_ID;
-const envAccuracyRunStatus = process.env.MDB_ACCURACY_RUN_STATUS;
-const commitSHA = await getCommitSHA();
-
-if (
-    !envAccuracyRunId ||
-    !commitSHA ||
-    (envAccuracyRunStatus !== AccuracyRunStatus.Done && envAccuracyRunStatus !== AccuracyRunStatus.Failed)
-) {
-    process.exit(1);
-}
-
-console.time(`Marked accuracy run id - ${envAccuracyRunId} as ${envAccuracyRunStatus} in`);
-const storage = getAccuracyResultStorage();
-await storage.updateRunStatus(commitSHA, envAccuracyRunId, envAccuracyRunStatus);
-await storage.close();
-console.timeEnd(`Marked accuracy run id - ${envAccuracyRunId} as ${envAccuracyRunStatus} in`);

package/scripts/apply.ts

@@ -1,135 +0,0 @@
-import fs from "fs/promises";
-import { OpenAPIV3_1 } from "openapi-types";
-import argv from "yargs-parser";
-
-function findObjectFromRef<T>(obj: T | OpenAPIV3_1.ReferenceObject, openapi: OpenAPIV3_1.Document): T {
-    const ref = (obj as OpenAPIV3_1.ReferenceObject).$ref;
-    if (ref === undefined) {
-        return obj as T;
-    }
-    const paramParts = ref.split("/");
-    paramParts.shift(); // Remove the first part which is always '#'
-
-    let foundObj: Record<string, unknown> = openapi;
-    while (true) {
-        const part = paramParts.shift();
-        if (!part) {
-            break;
-        }
-
-        foundObj = foundObj[part] as Record<string, unknown>;
-    }
-    return foundObj as T;
-}
-
-async function main() {
-    const { spec, file } = argv(process.argv.slice(2));
-
-    if (!spec || !file) {
-        console.error("Please provide both --spec and --file arguments.");
-        process.exit(1);
-    }
-
-    const specFile = await fs.readFile(spec as string, "utf8");
-
-    const operations: {
-        path: string;
-        method: string;
-        operationId: string;
-        requiredParams: boolean;
-        tag: string;
-        hasResponseBody: boolean;
-    }[] = [];
-
-    const openapi = JSON.parse(specFile) as OpenAPIV3_1.Document;
-    for (const path in openapi.paths) {
-        for (const method in openapi.paths[path]) {
-            // @ts-expect-error This is a workaround for the OpenAPI types
-            const operation = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
-
-            if (!operation.operationId || !operation.tags?.length) {
-                continue;
-            }
-
-            let requiredParams = !!operation.requestBody;
-            let hasResponseBody = false;
-            for (const code in operation.responses) {
-                try {
-                    const httpCode = parseInt(code, 10);
-                    if (httpCode >= 200 && httpCode < 300) {
-                        const response = operation.responses[code];
-                        const responseObject = findObjectFromRef(response, openapi) as OpenAPIV3_1.ResponseObject;
-                        if (responseObject && responseObject.content) {
-                            for (const contentType in responseObject.content) {
-                                const content = responseObject.content[contentType];
-                                hasResponseBody = !!content?.schema;
-                            }
-                        }
-                    }
-                } catch {
-                    continue;
-                }
-            }
-
-            for (const param of operation.parameters || []) {
-                const paramObject = findObjectFromRef(param, openapi);
-                if (paramObject.in === "path") {
-                    requiredParams = true;
-                }
-            }
-
-            operations.push({
-                path,
-                method: method.toUpperCase(),
-                operationId: operation.operationId || "",
-                requiredParams,
-                hasResponseBody,
-                tag: operation.tags?.[0] ?? "",
-            });
-        }
-    }
-
-    const operationOutput = operations
-        .map((operation) => {
-            const { operationId, method, path, requiredParams, hasResponseBody } = operation;
-            return `async ${operationId}(options${requiredParams ? "" : "?"}: FetchOptions<operations["${operationId}"]>) {
-    const { ${hasResponseBody ? `data, ` : ``}error, response } = await this.client.${method}("${path}", options);
-    if (error) {
-        throw ApiClientError.fromError(response, error);
-    }
-    ${
-        hasResponseBody
-            ? `return data;
-`
-            : ``
-    }}
-`;
-        })
-        .join("\n");
-
-    const templateFile = await fs.readFile(file as string, "utf8");
-    const templateLines = templateFile.split("\n");
-    const outputLines: string[] = [];
-    let addLines = true;
-    for (const line of templateLines) {
-        if (line.includes("DO NOT EDIT. This is auto-generated code.")) {
-            addLines = !addLines;
-            outputLines.push(line);
-            if (!addLines) {
-                outputLines.push(operationOutput);
-            }
-            continue;
-        }
-        if (addLines) {
-            outputLines.push(line);
-        }
-    }
-    const output = outputLines.join("\n");
-
-    await fs.writeFile(file as string, output, "utf8");
-}
-
-main().catch((error) => {
-    console.error("Error:", error);
-    process.exit(1);
-});

package/scripts/filter.ts

@@ -1,76 +0,0 @@
-import { OpenAPIV3_1 } from "openapi-types";
-
-async function readStdin() {
-    return new Promise<string>((resolve, reject) => {
-        let data = "";
-        process.stdin.setEncoding("utf8");
-        process.stdin.on("error", (err) => {
-            reject(err);
-        });
-        process.stdin.on("data", (chunk) => {
-            // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-            data += chunk;
-        });
-        process.stdin.on("end", () => {
-            resolve(data);
-        });
-    });
-}
-
-function filterOpenapi(openapi: OpenAPIV3_1.Document): OpenAPIV3_1.Document {
-    const allowedOperations = [
-        "listProjects",
-        "listOrganizations",
-        "getProject",
-        "createProject",
-        "deleteProject",
-        "listClusters",
-        "listFlexClusters",
-        "getCluster",
-        "getFlexCluster",
-        "createCluster",
-        "createFlexCluster",
-        "deleteCluster",
-        "deleteFlexCluster",
-        "listClustersForAllProjects",
-        "createDatabaseUser",
-        "deleteDatabaseUser",
-        "listDatabaseUsers",
-        "listProjectIpAccessLists",
-        "createProjectIpAccessList",
-        "deleteProjectIpAccessList",
-        "listOrganizationProjects",
-        "listAlerts",
-    ];
-
-    const filteredPaths = {};
-
-    for (const path in openapi.paths) {
-        const filteredMethods = {} as OpenAPIV3_1.PathItemObject;
-        for (const method in openapi.paths[path]) {
-            // @ts-expect-error This is a workaround for the OpenAPI types
-            if (allowedOperations.includes((openapi.paths[path][method] as { operationId: string }).operationId)) {
-                // @ts-expect-error This is a workaround for the OpenAPI types
-                filteredMethods[method] = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
-            }
-        }
-        if (Object.keys(filteredMethods).length > 0) {
-            // @ts-expect-error This is a workaround for the OpenAPI types
-            filteredPaths[path] = filteredMethods;
-        }
-    }
-
-    return { ...openapi, paths: filteredPaths };
-}
-
-async function main() {
-    const openapiText = await readStdin();
-    const openapi = JSON.parse(openapiText) as OpenAPIV3_1.Document;
-    const filteredOpenapi = filterOpenapi(openapi);
-    console.log(JSON.stringify(filteredOpenapi));
-}
-
-main().catch((error) => {
-    console.error("Error:", error);
-    process.exit(1);
-});

package/scripts/generate.sh

@@ -1,11 +0,0 @@
-#!/usr/bin/env bash
-
-set -Eeou pipefail
-
-curl -Lo ./scripts/spec.json https://github.com/mongodb/openapi/raw/refs/heads/main/openapi/v2/openapi-2025-03-12.json
-tsx ./scripts/filter.ts > ./scripts/filteredSpec.json < ./scripts/spec.json
-redocly bundle --ext json --remove-unused-components ./scripts/filteredSpec.json --output ./scripts/bundledSpec.json
-openapi-typescript ./scripts/bundledSpec.json --root-types-no-schema-prefix --root-types --output ./src/common/atlas/openapi.d.ts
-tsx ./scripts/apply.ts --spec ./scripts/bundledSpec.json --file ./src/common/atlas/apiClient.ts
-prettier --write ./src/common/atlas/openapi.d.ts ./src/common/atlas/apiClient.ts
-rm -rf ./scripts/bundledSpec.json ./scripts/filteredSpec.json ./scripts/spec.json

package/src/common/atlas/accessListUtils.ts

@@ -1,54 +0,0 @@
-import { ApiClient } from "./apiClient.js";
-import logger, { LogId } from "../logger.js";
-import { ApiClientError } from "./apiClientError.js";
-
-export const DEFAULT_ACCESS_LIST_COMMENT = "Added by MongoDB MCP Server to enable tool access";
-
-export async function makeCurrentIpAccessListEntry(
-    apiClient: ApiClient,
-    projectId: string,
-    comment: string = DEFAULT_ACCESS_LIST_COMMENT
-) {
-    const { currentIpv4Address } = await apiClient.getIpInfo();
-    return {
-        groupId: projectId,
-        ipAddress: currentIpv4Address,
-        comment,
-    };
-}
-
-/**
- * Ensures the current public IP is in the access list for the given Atlas project.
- * If the IP is already present, this is a no-op.
- * @param apiClient The Atlas API client instance
- * @param projectId The Atlas project ID
- */
-export async function ensureCurrentIpInAccessList(apiClient: ApiClient, projectId: string): Promise<void> {
-    const entry = await makeCurrentIpAccessListEntry(apiClient, projectId, DEFAULT_ACCESS_LIST_COMMENT);
-    try {
-        await apiClient.createProjectIpAccessList({
-            params: { path: { groupId: projectId } },
-            body: [entry],
-        });
-        logger.debug(
-            LogId.atlasIpAccessListAdded,
-            "accessListUtils",
-            `IP access list created: ${JSON.stringify(entry)}`
-        );
-    } catch (err) {
-        if (err instanceof ApiClientError && err.response?.status === 409) {
-            // 409 Conflict: entry already exists, log info
-            logger.debug(
-                LogId.atlasIpAccessListAdded,
-                "accessListUtils",
-                `IP address ${entry.ipAddress} is already present in the access list for project ${projectId}.`
-            );
-            return;
-        }
-        logger.warning(
-            LogId.atlasIpAccessListAddFailure,
-            "accessListUtils",
-            `Error adding IP access list: ${err instanceof Error ? err.message : String(err)}`
-        );
-    }
-}