Merge remote-tracking branch 'origin/main' into dependabot/npm_and_yarn/typescript-eslint-8.46.3

Author: blva

.github/workflows/code-health-fork.yml

@@ -36,12 +36,18 @@ jobs:
         run: npm ci
       - name: Run tests
         run: npm test
-        env:
-          SKIP_ATLAS_TESTS: "true"
-          SKIP_ATLAS_LOCAL_TESTS: "true"
-      - name: Upload test results
-        if: always() && matrix.os == 'ubuntu-latest'
-        uses: actions/upload-artifact@v5
+  run-atlas-local-tests:
+    name: Run Atlas Local tests
+    if: github.event.pull_request.user.login == 'dependabot[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: GitHubSecurityLab/actions-permissions/monitor@v1
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v4
         with:
-          name: test-results
-          path: coverage/lcov.info
+          node-version-file: package.json
+          cache: "npm"
+      - name: Install dependencies
+        run: npm ci
+      - name: Run tests
+        run: npm test -- tests/integration/tools/atlas-local/

package-lock.json

@@ -319,7 +319,7 @@ export function warnAboutDeprecatedOrUnknownCliArgs(
     if (knownArgs.connectionString) {
         usedDeprecatedArgument = true;
         warn(
-            "The --connectionString argument is deprecated. Prefer using the MDB_MCP_CONNECTION_STRING environment variable or the first positional argument for the connection string."
+            "Warning: The --connectionString argument is deprecated. Prefer using the MDB_MCP_CONNECTION_STRING environment variable or the first positional argument for the connection string."
         );
     }
 
@@ -333,15 +333,15 @@ export function warnAboutDeprecatedOrUnknownCliArgs(
         if (!valid) {
             usedInvalidArgument = true;
             if (suggestion) {
-                warn(`Invalid command line argument '${providedKey}'. Did you mean '${suggestion}'?`);
+                warn(`Warning: Invalid command line argument '${providedKey}'. Did you mean '${suggestion}'?`);
             } else {
-                warn(`Invalid command line argument '${providedKey}'.`);
+                warn(`Warning: Invalid command line argument '${providedKey}'.`);
             }
         }
     }
 
     if (usedInvalidArgument || usedDeprecatedArgument) {
-        warn("Refer to https://www.mongodb.com/docs/mcp-server/get-started/ for setting up the MCP Server.");
+        warn("- Refer to https://www.mongodb.com/docs/mcp-server/get-started/ for setting up the MCP Server.");
     }
 
     if (usedInvalidArgument) {
@@ -372,6 +372,24 @@ export function registerKnownSecretsInRootKeychain(userConfig: Partial<UserConfi
     maybeRegister(userConfig.username, "user");
 }
 
+export function warnIfVectorSearchNotEnabledCorrectly(config: UserConfig, warn: (message: string) => void): void {
+    const vectorSearchEnabled = config.previewFeatures.includes("vectorSearch");
+    const embeddingsProviderConfigured = !!config.voyageApiKey;
+    if (vectorSearchEnabled && !embeddingsProviderConfigured) {
+        warn(`\
+Warning: Vector search is enabled but no embeddings provider is configured.
+- Set an embeddings provider configuration option to enable auto-embeddings during document insertion and text-based queries with $vectorSearch.\
+`);
+    }
+
+    if (!vectorSearchEnabled && embeddingsProviderConfigured) {
+        warn(`\
+Warning: An embeddings provider is configured but the 'vectorSearch' preview feature is not enabled.
+- Enable vector search by adding 'vectorSearch' to the 'previewFeatures' configuration option, or remove the embeddings provider configuration if not needed.\
+`);
+    }
+}
+
 export function setupUserConfig({ cli, env }: { cli: string[]; env: Record<string, unknown> }): UserConfig {
     const rawConfig = {
         ...parseEnvConfig(env),
@@ -392,6 +410,7 @@ export function setupUserConfig({ cli, env }: { cli: string[]; env: Record<strin
     // We don't have as schema defined for all args-parser arguments so we need to merge the raw config with the parsed config.
     const userConfig = { ...rawConfig, ...parseResult.data } as UserConfig;
 
+    warnIfVectorSearchNotEnabledCorrectly(userConfig, (message) => console.warn(message));
     registerKnownSecretsInRootKeychain(userConfig);
     return userConfig;
 }

src/common/config.ts

@@ -24,10 +24,8 @@ export type VectorFieldIndexDefinition = {
 export type VectorFieldValidationError = {
     path: string;
     expectedNumDimensions: number;
-    expectedQuantization: Quantization;
     actualNumDimensions: number | "unknown";
-    actualQuantization: Quantization | "unknown";
-    error: "dimension-mismatch" | "quantization-mismatch" | "not-a-vector" | "not-numeric";
+    error: "dimension-mismatch" | "not-a-vector" | "not-numeric";
 };
 
 export type EmbeddingNamespace = `${string}.${string}`;
@@ -116,9 +114,9 @@ export class VectorSearchEmbeddingsManager {
         if (embeddingValidationResults.length > 0) {
             const embeddingValidationMessages = embeddingValidationResults.map(
                 (validation) =>
-                    `- Field ${validation.path} is an embedding with ${validation.expectedNumDimensions} dimensions and ${validation.expectedQuantization}` +
-                    ` quantization, and the provided value is not compatible. Actual dimensions: ${validation.actualNumDimensions}, ` +
-                    `actual quantization: ${validation.actualQuantization}. Error: ${validation.error}`
+                    `- Field ${validation.path} is an embedding with ${validation.expectedNumDimensions} dimensions,` +
+                    ` and the provided value is not compatible. Actual dimensions: ${validation.actualNumDimensions},` +
+                    ` Error: ${validation.error}`
             );
 
             throw new MongoDBError(
@@ -179,16 +177,36 @@ export class VectorSearchEmbeddingsManager {
         let fieldRef: unknown = document;
 
         const constructError = (
-            details: Partial<Pick<VectorFieldValidationError, "error" | "actualNumDimensions" | "actualQuantization">>
+            details: Partial<Pick<VectorFieldValidationError, "error" | "actualNumDimensions">>
         ): VectorFieldValidationError => ({
             path: definition.path,
             expectedNumDimensions: definition.numDimensions,
-            expectedQuantization: definition.quantization,
             actualNumDimensions: details.actualNumDimensions ?? "unknown",
-            actualQuantization: details.actualQuantization ?? "unknown",
             error: details.error ?? "not-a-vector",
         });
 
+        const extractUnderlyingVector = (fieldRef: unknown): ArrayLike<unknown> | undefined => {
+            if (fieldRef instanceof BSON.Binary) {
+                try {
+                    return fieldRef.toFloat32Array();
+                } catch {
+                    // nothing to do here
+                }
+
+                try {
+                    return fieldRef.toBits();
+                } catch {
+                    // nothing to do here
+                }
+            }
+
+            if (Array.isArray(fieldRef)) {
+                return fieldRef as Array<unknown>;
+            }
+
+            return undefined;
+        };
+
         for (const field of fieldPath) {
             if (fieldRef && typeof fieldRef === "object" && field in fieldRef) {
                 fieldRef = (fieldRef as Record<string, unknown>)[field];
@@ -197,70 +215,25 @@ export class VectorSearchEmbeddingsManager {
             }
         }
 
-        switch (definition.quantization) {
-            // Because quantization is not defined by the user
-            // we have to trust them in the format they use.
-            case "none":
-                return undefined;
-            case "scalar":
-            case "binary":
-                if (fieldRef instanceof BSON.Binary) {
-                    try {
-                        const elements = fieldRef.toFloat32Array();
-                        if (elements.length !== definition.numDimensions) {
-                            return constructError({
-                                actualNumDimensions: elements.length,
-                                actualQuantization: "binary",
-                                error: "dimension-mismatch",
-                            });
-                        }
-
-                        return undefined;
-                    } catch {
-                        // bits are also supported
-                        try {
-                            const bits = fieldRef.toBits();
-                            if (bits.length !== definition.numDimensions) {
-                                return constructError({
-                                    actualNumDimensions: bits.length,
-                                    actualQuantization: "binary",
-                                    error: "dimension-mismatch",
-                                });
-                            }
-
-                            return undefined;
-                        } catch {
-                            return constructError({
-                                actualQuantization: "binary",
-                                error: "not-a-vector",
-                            });
-                        }
-                    }
-                } else {
-                    if (!Array.isArray(fieldRef)) {
-                        return constructError({
-                            error: "not-a-vector",
-                        });
-                    }
-
-                    if (fieldRef.length !== definition.numDimensions) {
-                        return constructError({
-                            actualNumDimensions: fieldRef.length,
-                            actualQuantization: "scalar",
-                            error: "dimension-mismatch",
-                        });
-                    }
-
-                    if (!fieldRef.every((e) => this.isANumber(e))) {
-                        return constructError({
-                            actualNumDimensions: fieldRef.length,
-                            actualQuantization: "scalar",
-                            error: "not-numeric",
-                        });
-                    }
-                }
+        const maybeVector = extractUnderlyingVector(fieldRef);
+        if (!maybeVector) {
+            return constructError({
+                error: "not-a-vector",
+            });
+        }
 
-                break;
+        if (maybeVector.length !== definition.numDimensions) {
+            return constructError({
+                actualNumDimensions: maybeVector.length,
+                error: "dimension-mismatch",
+            });
+        }
+
+        if (Array.isArray(maybeVector) && maybeVector.some((e) => !this.isANumber(e))) {
+            return constructError({
+                actualNumDimensions: maybeVector.length,
+                error: "not-numeric",
+            });
         }
 
         return undefined;

src/common/search/vectorSearchEmbeddingsManager.ts

@@ -218,6 +218,39 @@ export class ConnectClusterTool extends AtlasToolBase {
         const ipAccessListUpdated = await ensureCurrentIpInAccessList(this.session.apiClient, projectId);
         let createdUser = false;
 
+        const state = this.queryConnection(projectId, clusterName);
+        switch (state) {
+            case "connected-to-other-cluster":
+            case "disconnected": {
+                await this.session.disconnect();
+
+                const { connectionString, atlas } = await this.prepareClusterConnection(
+                    projectId,
+                    clusterName,
+                    connectionType
+                );
+
+                createdUser = true;
+
+                // try to connect for about 5 minutes asynchronously
+                void this.connectToCluster(connectionString, atlas).catch((err: unknown) => {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    this.session.logger.error({
+                        id: LogId.atlasConnectFailure,
+                        context: "atlas-connect-cluster",
+                        message: `error connecting to cluster: ${error.message}`,
+                    });
+                });
+                break;
+            }
+            case "connecting":
+            case "connected":
+            case "unknown":
+            default: {
+                break;
+            }
+        }
+
         for (let i = 0; i < 60; i++) {
             const state = this.queryConnection(projectId, clusterName);
             switch (state) {
@@ -246,34 +279,15 @@ export class ConnectClusterTool extends AtlasToolBase {
                     return { content };
                 }
                 case "connecting":
-                case "unknown": {
-                    break;
-                }
+                case "unknown":
                 case "connected-to-other-cluster":
                 case "disconnected":
                 default: {
-                    await this.session.disconnect();
-                    const { connectionString, atlas } = await this.prepareClusterConnection(
-                        projectId,
-                        clusterName,
-                        connectionType
-                    );
-
-                    createdUser = true;
-                    // try to connect for about 5 minutes asynchronously
-                    void this.connectToCluster(connectionString, atlas).catch((err: unknown) => {
-                        const error = err instanceof Error ? err : new Error(String(err));
-                        this.session.logger.error({
-                            id: LogId.atlasConnectFailure,
-                            context: "atlas-connect-cluster",
-                            message: `error connecting to cluster: ${error.message}`,
-                        });
-                    });
                     break;
                 }
             }
 
-            await sleep(500);
+            await sleep(500); // wait 500ms before checking the connection state again
         }
 
         const content: CallToolResult["content"] = [

src/tools/atlas/connect/connectCluster.ts

@@ -80,7 +80,7 @@ export class CreateIndexTool extends MongoDBToolBase {
                 ])
             )
             .describe(
-                "The index definition. Use 'classic' for standard indexes and 'vectorSearch' for vector search indexes"
+                `The index definition. Use 'classic' for standard indexes${this.isFeatureEnabled("vectorSearch") ? " and 'vectorSearch' for vector search indexes" : ""}.`
             ),
     };
 

src/tools/mongodb/create/createIndex.ts

@@ -4,7 +4,7 @@ import type { ToolArgs, OperationType } from "../../tool.js";
 import { formatUntrustedData } from "../../tool.js";
 import { z } from "zod";
 import type { Document } from "mongodb";
-import { AggregateArgs } from "../read/aggregate.js";
+import { getAggregateArgs } from "../read/aggregate.js";
 import { FindArgs } from "../read/find.js";
 import { CountArgs } from "../read/count.js";
 
@@ -20,7 +20,7 @@ export class ExplainTool extends MongoDBToolBase {
                 z.discriminatedUnion("name", [
                     z.object({
                         name: z.literal("aggregate"),
-                        arguments: z.object(AggregateArgs),
+                        arguments: z.object(getAggregateArgs(this.isFeatureEnabled("vectorSearch"))),
                     }),
                     z.object({
                         name: z.literal("find"),

src/tools/mongodb/metadata/explain.ts

@@ -42,7 +42,7 @@ export type EmbeddingParameters = {
 export const zSupportedEmbeddingParameters = zVoyageEmbeddingParameters.extend({ model: zVoyageModels });
 export type SupportedEmbeddingParameters = z.infer<typeof zSupportedEmbeddingParameters>;
 
-export const AnyVectorSearchStage = zEJSON();
+export const AnyAggregateStage = zEJSON();
 export const VectorSearchStage = z.object({
     $vectorSearch: z
         .object({