mongodb-mcp-server 0.1.3 → 0.2.0

package/scripts/accuracy/generateTestSummary.ts

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

@@ -0,0 +1,45 @@
+#!/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

@@ -0,0 +1,21 @@
+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/src/common/atlas/accessListUtils.ts

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

package/src/common/atlas/apiClient.ts

@@ -4,7 +4,8 @@ import { AccessToken, ClientCredentials } from "simple-oauth2";
 import { ApiClientError } from "./apiClientError.js";
 import { paths, operations } from "./openapi.js";
 import { CommonProperties, TelemetryEvent } from "../../telemetry/types.js";
-import { packageInfo } from "../../helpers/packageInfo.js";
+import { packageInfo } from "../packageInfo.js";
+import logger, { LogId } from "../logger.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
 
@@ -34,9 +35,7 @@ export class ApiClient {
 
     private getAccessToken = async () => {
         if (this.oauth2Client && (!this.accessToken || this.accessToken.expired())) {
-            this.accessToken = await this.oauth2Client.getToken({
-                agent: this.options.userAgent,
-            });
+            this.accessToken = await this.oauth2Client.getToken({});
         }
         return this.accessToken?.token.access_token as string | undefined;
     };
@@ -49,7 +48,9 @@ export class ApiClient {
 
             try {
                 const accessToken = await this.getAccessToken();
-                request.headers.set("Authorization", `Bearer ${accessToken}`);
+                if (accessToken) {
+                    request.headers.set("Authorization", `Bearer ${accessToken}`);
+                }
                 return request;
             } catch {
                 // ignore not availble tokens, API will return 401
@@ -81,6 +82,12 @@ export class ApiClient {
                 auth: {
                     tokenHost: this.options.baseUrl,
                     tokenPath: "/api/oauth/token",
+                    revokePath: "/api/oauth/revoke",
+                },
+                http: {
+                    headers: {
+                        "User-Agent": this.options.userAgent,
+                    },
                 },
             });
             this.client.use(this.authMiddleware);
@@ -88,13 +95,25 @@ export class ApiClient {
     }
 
     public hasCredentials(): boolean {
-        return !!(this.oauth2Client && this.accessToken);
+        return !!this.oauth2Client;
     }
 
     public async validateAccessToken(): Promise<void> {
         await this.getAccessToken();
     }
 
+    public async close(): Promise<void> {
+        if (this.accessToken) {
+            try {
+                await this.accessToken.revoke("access_token");
+            } catch (error: unknown) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                logger.error(LogId.atlasApiRevokeFailure, "apiClient", `Failed to revoke access token: ${err.message}`);
+            }
+            this.accessToken = undefined;
+        }
+    }
+
     public async getIpInfo(): Promise<{
         currentIpv4Address: string;
     }> {

package/src/common/atlas/cluster.ts

@@ -1,6 +1,6 @@
 import { ClusterDescription20240805, FlexClusterDescription20241113 } from "./openapi.js";
 import { ApiClient } from "./apiClient.js";
-import logger, { LogId } from "../../logger.js";
+import logger, { LogId } from "../logger.js";
 
 export interface Cluster {
     name?: string;

package/src/{config.ts → common/config.ts}

@@ -17,13 +17,19 @@ export interface UserConfig {
     apiBaseUrl: string;
     apiClientId?: string;
     apiClientSecret?: string;
-    telemetry?: "enabled" | "disabled";
+    telemetry: "enabled" | "disabled";
     logPath: string;
     connectionString?: string;
     connectOptions: ConnectOptions;
     disabledTools: Array<string>;
     readOnly?: boolean;
     indexCheck?: boolean;
+    transport: "stdio" | "http";
+    httpPort: number;
+    httpHost: string;
+    loggers: Array<"stderr" | "disk" | "mcp">;
+    idleTimeoutMs: number;
+    notificationTimeoutMs: number;
 }
 
 const defaults: UserConfig = {
@@ -39,6 +45,12 @@ const defaults: UserConfig = {
     telemetry: "enabled",
     readOnly: false,
     indexCheck: false,
+    transport: "stdio",
+    httpPort: 3000,
+    httpHost: "127.0.0.1",
+    loggers: ["disk", "mcp"],
+    idleTimeoutMs: 600000, // 10 minutes
+    notificationTimeoutMs: 540000, // 9 minutes
 };
 
 export const config = {
@@ -120,6 +132,6 @@ function SNAKE_CASE_toCamelCase(str: string): string {
 // Reads the cli args and parses them into a UserConfig object.
 function getCliConfig() {
     return argv(process.argv.slice(2), {
-        array: ["disabledTools"],
+        array: ["disabledTools", "loggers"],
     }) as unknown as Partial<UserConfig>;
 }

package/src/{logger.ts → common/logger.ts}

@@ -12,11 +12,17 @@ export const LogId = {
     serverCloseRequested: mongoLogId(1_000_003),
     serverClosed: mongoLogId(1_000_004),
     serverCloseFailure: mongoLogId(1_000_005),
+    serverDuplicateLoggers: mongoLogId(1_000_006),
 
     atlasCheckCredentials: mongoLogId(1_001_001),
     atlasDeleteDatabaseUserFailure: mongoLogId(1_001_002),
     atlasConnectFailure: mongoLogId(1_001_003),
     atlasInspectFailure: mongoLogId(1_001_004),
+    atlasConnectAttempt: mongoLogId(1_001_005),
+    atlasConnectSucceeded: mongoLogId(1_001_006),
+    atlasApiRevokeFailure: mongoLogId(1_001_007),
+    atlasIpAccessListAdded: mongoLogId(1_001_008),
+    atlasIpAccessListAddFailure: mongoLogId(1_001_009),
 
     telemetryDisabled: mongoLogId(1_002_001),
     telemetryEmitFailure: mongoLogId(1_002_002),
@@ -34,9 +40,16 @@ export const LogId = {
     mongodbDisconnectFailure: mongoLogId(1_004_002),
 
     toolUpdateFailure: mongoLogId(1_005_001),
+
+    streamableHttpTransportStarted: mongoLogId(1_006_001),
+    streamableHttpTransportSessionCloseFailure: mongoLogId(1_006_002),
+    streamableHttpTransportSessionCloseNotification: mongoLogId(1_006_003),
+    streamableHttpTransportSessionCloseNotificationFailure: mongoLogId(1_006_004),
+    streamableHttpTransportRequestFailure: mongoLogId(1_006_005),
+    streamableHttpTransportCloseFailure: mongoLogId(1_006_006),
 } as const;
 
-abstract class LoggerBase {
+export abstract class LoggerBase {
     abstract log(level: LogLevel, id: MongoLogId, context: string, message: string): void;
 
     info(id: MongoLogId, context: string, message: string): void {
@@ -71,14 +84,14 @@ abstract class LoggerBase {
     }
 }
 
-class ConsoleLogger extends LoggerBase {
+export class ConsoleLogger extends LoggerBase {
     log(level: LogLevel, id: MongoLogId, context: string, message: string): void {
         message = redact(message);
-        console.error(`[${level.toUpperCase()}] ${id.__value} - ${context}: ${message}`);
+        console.error(`[${level.toUpperCase()}] ${id.__value} - ${context}: ${message} (${process.pid})`);
     }
 }
 
-class DiskLogger extends LoggerBase {
+export class DiskLogger extends LoggerBase {
     private constructor(private logWriter: MongoLogWriter) {
         super();
     }
@@ -130,7 +143,7 @@ class DiskLogger extends LoggerBase {
     }
 }
 
-class McpLogger extends LoggerBase {
+export class McpLogger extends LoggerBase {
     constructor(private server: McpServer) {
         super();
     }
@@ -149,18 +162,12 @@ class McpLogger extends LoggerBase {
 }
 
 class CompositeLogger extends LoggerBase {
-    private loggers: LoggerBase[];
+    private loggers: LoggerBase[] = [];
 
     constructor(...loggers: LoggerBase[]) {
         super();
 
-        if (loggers.length === 0) {
-            // default to ConsoleLogger
-            this.loggers = [new ConsoleLogger()];
-            return;
-        }
-
-        this.loggers = [...loggers];
+        this.setLoggers(...loggers);
     }
 
     setLoggers(...loggers: LoggerBase[]): void {
@@ -177,14 +184,5 @@ class CompositeLogger extends LoggerBase {
     }
 }
 
-const logger = new CompositeLogger();
+const logger = new CompositeLogger(new ConsoleLogger());
 export default logger;
-
-export async function initializeLogger(server: McpServer, logPath: string): Promise<LoggerBase> {
-    const diskLogger = await DiskLogger.fromPath(logPath);
-    const mcpLogger = new McpLogger(server);
-
-    logger.setLoggers(mcpLogger, diskLogger);
-
-    return logger;
-}