@himanshusinghs/mongodb-mcp-server 1.7.7 → 1.11.0-prerelease.2

package/dist/cjs/tools/mongodb/read/aggregate.d.ts

@@ -2,345 +2,78 @@ import { z } from "zod";
 import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { MongoDBToolBase } from "../mongodbTool.js";
 import type { ToolArgs, OperationType, ToolExecutionContext } from "../../tool.js";
-import type { AutoEmbeddingsUsageMetadata, ConnectionMetadata } from "../../../telemetry/types.js";
-export declare const pipelineDescriptionWithVectorSearch = "An array of aggregation stages to execute.\nIf the user has asked for a vector search, `$vectorSearch` **MUST** be the first stage of the pipeline, or the first stage of a `$unionWith` subpipeline.\nIf the user has asked for lexical/Atlas search, use `$search` instead of `$text`.\n### Usage Rules for `$vectorSearch`\n- **Index Type Detection:**\n  Use the collection-indexes tool to determine if the target field has a classic vector index (type: 'vector') or an auto-embed index (type: 'autoEmbed').\n- **Classic Vector Search (type: 'vector'):**\n  Use 'queryVector' with embeddings as an array of numbers, or as a string with 'embeddingParameters' to generate embeddings.\n- **Auto-Embed Vector Search (type: 'autoEmbed'):**\n  Use 'query' - MongoDB automatically generates embeddings at query time. Do NOT use 'queryVector' or 'embeddingParameters' for auto-embed indexes.\n- **Unset embeddings:**\n  Unless the user explicitly requests the embeddings, add an `$unset` stage **at the end of the pipeline** to remove the embedding field and avoid context limits. **The $unset stage in this situation is mandatory**.\n- **Pre-filtering:**\n  If the user requests additional filtering, include filters in `$vectorSearch.filter` only for pre-filter fields in the vector index.\n  NEVER include fields in $vectorSearch.filter that are not part of the vector index.\n- **Post-filtering:**\n  For all remaining filters, add a $match stage after $vectorSearch.\n- If unsure which fields are filterable, use the collection-indexes tool to determine valid prefilter fields.\n- If no requested filters are valid prefilters, omit the filter key from $vectorSearch.\n\n### Usage Rules for `$search`\n- Include the index name, unless you know for a fact there's a default index. If unsure, use the collection-indexes tool to determine the index name.\n- The `$search` stage supports multiple operators, such as 'autocomplete', 'text', 'geoWithin', and others. Choose the approprate operator based on the user's query. If unsure of the exact syntax, consult the MongoDB Atlas Search documentation, which can be found here: https://www.mongodb.com/docs/atlas/atlas-search/operators-and-collectors/\n";
-export declare const getAggregateArgs: (vectorSearchEnabled: boolean) => {
-    readonly pipeline: z.ZodArray<z.AnyZodObject | z.ZodUnion<[z.ZodObject<{
-        $vectorSearch: z.ZodUnion<[z.ZodObject<{
+export declare const pipelineDescriptionWithVectorSearch = "An array of aggregation stages to execute.\nIf the user has asked for a vector search, `$vectorSearch` **MUST** be the first stage of the pipeline, or the first stage of a `$unionWith` subpipeline.\nIf the user has asked for lexical/Atlas search, use `$search` instead of `$text`.\n### Usage Rules for `$vectorSearch`\n- **Index Type Detection:**\n  Use the collection-indexes tool to determine if the target field has a classic vector index (type: 'vector') or an auto-embed index (type: 'autoEmbed').\n- **Classic Vector Search (type: 'vector'):**\n  Use 'queryVector' with embeddings as an array of numbers.\n- **Auto-Embed Vector Search (type: 'autoEmbed'):**\n  Use 'query' - MongoDB automatically generates embeddings at query time. Do NOT use 'queryVector' or 'embeddingParameters' for auto-embed indexes.\n- **Unset embeddings:**\n  Unless the user explicitly requests the embeddings, add an `$unset` stage **at the end of the pipeline** to remove the embedding field and avoid context limits. **The $unset stage in this situation is mandatory**.\n- **Pre-filtering:**\n  If the user requests additional filtering, include filters in `$vectorSearch.filter` only for pre-filter fields in the vector index.\n  NEVER include fields in $vectorSearch.filter that are not part of the vector index.\n- **Post-filtering:**\n  For all remaining filters, add a $match stage after $vectorSearch.\n- If unsure which fields are filterable, use the collection-indexes tool to determine valid prefilter fields.\n- If no requested filters are valid prefilters, omit the filter key from $vectorSearch.\n\n### Usage Rules for `$search`\n- Include the index name, unless you know for a fact there's a default index. If unsure, use the collection-indexes tool to determine the index name.\n- The `$search` stage supports multiple operators, such as 'autocomplete', 'text', 'geoWithin', and others. Choose the approprate operator based on the user's query. If unsure of the exact syntax, consult the MongoDB Atlas Search documentation, which can be found here: https://www.mongodb.com/docs/atlas/atlas-search/operators-and-collectors/\n";
+export declare const AggregateArgs: {
+    pipeline: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        $vectorSearch: z.ZodUnion<readonly [z.ZodObject<{
             exact: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             index: z.ZodString;
             path: z.ZodString;
             numCandidates: z.ZodOptional<z.ZodNumber>;
             limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            filter: z.ZodOptional<z.AnyZodObject>;
-        } & {
-            queryVector: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodNumber, "many">]>;
-            embeddingParameters: z.ZodOptional<z.ZodObject<{
-                outputDimension: z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"256">, z.ZodLiteral<"512">, z.ZodLiteral<"1024">, z.ZodLiteral<"2048">, z.ZodLiteral<"4096">]>>, number, "256" | "512" | "1024" | "2048" | "4096" | undefined>>;
-                outputDtype: z.ZodDefault<z.ZodOptional<z.ZodEnum<["float", "int8", "uint8", "binary", "ubinary"]>>>;
-            } & {
-                model: z.ZodDefault<z.ZodEnum<["voyage-3-large", "voyage-3.5", "voyage-3.5-lite", "voyage-code-3"]>>;
-            }, "strip", z.ZodTypeAny, {
-                outputDtype: "binary" | "float" | "int8" | "uint8" | "ubinary";
-                model: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3";
-                outputDimension?: number | undefined;
-            }, {
-                outputDimension?: "256" | "512" | "1024" | "2048" | "4096" | undefined;
-                outputDtype?: "binary" | "float" | "int8" | "uint8" | "ubinary" | undefined;
-                model?: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3" | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            path: string;
-            exact: boolean;
-            index: string;
-            limit: number;
-            queryVector: string | number[];
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            numCandidates?: number | undefined;
-            embeddingParameters?: {
-                outputDtype: "binary" | "float" | "int8" | "uint8" | "ubinary";
-                model: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3";
-                outputDimension?: number | undefined;
-            } | undefined;
-        }, {
-            path: string;
-            index: string;
-            queryVector: string | number[];
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            exact?: boolean | undefined;
-            numCandidates?: number | undefined;
-            limit?: number | undefined;
-            embeddingParameters?: {
-                outputDimension?: "256" | "512" | "1024" | "2048" | "4096" | undefined;
-                outputDtype?: "binary" | "float" | "int8" | "uint8" | "ubinary" | undefined;
-                model?: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3" | undefined;
-            } | undefined;
-        }>, z.ZodObject<{
+            filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            queryVector: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
             exact: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             index: z.ZodString;
             path: z.ZodString;
             numCandidates: z.ZodOptional<z.ZodNumber>;
             limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-            filter: z.ZodOptional<z.AnyZodObject>;
-        } & {
+            filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             query: z.ZodObject<{
                 text: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                text: string;
-            }, {
-                text: string;
-            }>;
-            model: z.ZodOptional<z.ZodEnum<["voyage-4", "voyage-4-large", "voyage-4-lite", "voyage-code-3"]>>;
-        }, "strip", z.ZodTypeAny, {
-            query: {
-                text: string;
-            };
-            path: string;
-            exact: boolean;
-            index: string;
-            limit: number;
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-            numCandidates?: number | undefined;
-        }, {
-            query: {
-                text: string;
-            };
-            path: string;
-            index: string;
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            exact?: boolean | undefined;
-            model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-            numCandidates?: number | undefined;
-            limit?: number | undefined;
-        }>]>;
-    }, "strip", z.ZodTypeAny, {
-        $vectorSearch: {
-            path: string;
-            exact: boolean;
-            index: string;
-            limit: number;
-            queryVector: string | number[];
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            numCandidates?: number | undefined;
-            embeddingParameters?: {
-                outputDtype: "binary" | "float" | "int8" | "uint8" | "ubinary";
-                model: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3";
-                outputDimension?: number | undefined;
-            } | undefined;
-        } | {
-            query: {
-                text: string;
-            };
-            path: string;
-            exact: boolean;
-            index: string;
-            limit: number;
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-            numCandidates?: number | undefined;
-        };
-    }, {
-        $vectorSearch: {
-            path: string;
-            index: string;
-            queryVector: string | number[];
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            exact?: boolean | undefined;
-            numCandidates?: number | undefined;
-            limit?: number | undefined;
-            embeddingParameters?: {
-                outputDimension?: "256" | "512" | "1024" | "2048" | "4096" | undefined;
-                outputDtype?: "binary" | "float" | "int8" | "uint8" | "ubinary" | undefined;
-                model?: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3" | undefined;
-            } | undefined;
-        } | {
-            query: {
-                text: string;
-            };
-            path: string;
-            index: string;
-            filter?: {
-                [x: string]: any;
-            } | undefined;
-            exact?: boolean | undefined;
-            model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-            numCandidates?: number | undefined;
-            limit?: number | undefined;
-        };
-    }>, z.AnyZodObject]>, "many">;
+            }, z.core.$strip>;
+            model: z.ZodOptional<z.ZodEnum<{
+                "voyage-4": "voyage-4";
+                "voyage-4-large": "voyage-4-large";
+                "voyage-4-lite": "voyage-4-lite";
+                "voyage-code-3": "voyage-code-3";
+            }>>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
 };
 export declare class AggregateTool extends MongoDBToolBase {
     static toolName: string;
     description: string;
     argsShape: {
         responseBytesLimit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-        pipeline: z.ZodArray<z.AnyZodObject | z.ZodUnion<[z.ZodObject<{
-            $vectorSearch: z.ZodUnion<[z.ZodObject<{
+        pipeline: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            $vectorSearch: z.ZodUnion<readonly [z.ZodObject<{
                 exact: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 index: z.ZodString;
                 path: z.ZodString;
                 numCandidates: z.ZodOptional<z.ZodNumber>;
                 limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-                filter: z.ZodOptional<z.AnyZodObject>;
-            } & {
-                queryVector: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodNumber, "many">]>;
-                embeddingParameters: z.ZodOptional<z.ZodObject<{
-                    outputDimension: z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"256">, z.ZodLiteral<"512">, z.ZodLiteral<"1024">, z.ZodLiteral<"2048">, z.ZodLiteral<"4096">]>>, number, "256" | "512" | "1024" | "2048" | "4096" | undefined>>;
-                    outputDtype: z.ZodDefault<z.ZodOptional<z.ZodEnum<["float", "int8", "uint8", "binary", "ubinary"]>>>;
-                } & {
-                    model: z.ZodDefault<z.ZodEnum<["voyage-3-large", "voyage-3.5", "voyage-3.5-lite", "voyage-code-3"]>>;
-                }, "strip", z.ZodTypeAny, {
-                    outputDtype: "binary" | "float" | "int8" | "uint8" | "ubinary";
-                    model: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3";
-                    outputDimension?: number | undefined;
-                }, {
-                    outputDimension?: "256" | "512" | "1024" | "2048" | "4096" | undefined;
-                    outputDtype?: "binary" | "float" | "int8" | "uint8" | "ubinary" | undefined;
-                    model?: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3" | undefined;
-                }>>;
-            }, "strip", z.ZodTypeAny, {
-                path: string;
-                exact: boolean;
-                index: string;
-                limit: number;
-                queryVector: string | number[];
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                numCandidates?: number | undefined;
-                embeddingParameters?: {
-                    outputDtype: "binary" | "float" | "int8" | "uint8" | "ubinary";
-                    model: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3";
-                    outputDimension?: number | undefined;
-                } | undefined;
-            }, {
-                path: string;
-                index: string;
-                queryVector: string | number[];
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                exact?: boolean | undefined;
-                numCandidates?: number | undefined;
-                limit?: number | undefined;
-                embeddingParameters?: {
-                    outputDimension?: "256" | "512" | "1024" | "2048" | "4096" | undefined;
-                    outputDtype?: "binary" | "float" | "int8" | "uint8" | "ubinary" | undefined;
-                    model?: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3" | undefined;
-                } | undefined;
-            }>, z.ZodObject<{
+                filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                queryVector: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
                 exact: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
                 index: z.ZodString;
                 path: z.ZodString;
                 numCandidates: z.ZodOptional<z.ZodNumber>;
                 limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-                filter: z.ZodOptional<z.AnyZodObject>;
-            } & {
+                filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                 query: z.ZodObject<{
                     text: z.ZodString;
-                }, "strip", z.ZodTypeAny, {
-                    text: string;
-                }, {
-                    text: string;
-                }>;
-                model: z.ZodOptional<z.ZodEnum<["voyage-4", "voyage-4-large", "voyage-4-lite", "voyage-code-3"]>>;
-            }, "strip", z.ZodTypeAny, {
-                query: {
-                    text: string;
-                };
-                path: string;
-                exact: boolean;
-                index: string;
-                limit: number;
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-                numCandidates?: number | undefined;
-            }, {
-                query: {
-                    text: string;
-                };
-                path: string;
-                index: string;
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                exact?: boolean | undefined;
-                model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-                numCandidates?: number | undefined;
-                limit?: number | undefined;
-            }>]>;
-        }, "strip", z.ZodTypeAny, {
-            $vectorSearch: {
-                path: string;
-                exact: boolean;
-                index: string;
-                limit: number;
-                queryVector: string | number[];
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                numCandidates?: number | undefined;
-                embeddingParameters?: {
-                    outputDtype: "binary" | "float" | "int8" | "uint8" | "ubinary";
-                    model: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3";
-                    outputDimension?: number | undefined;
-                } | undefined;
-            } | {
-                query: {
-                    text: string;
-                };
-                path: string;
-                exact: boolean;
-                index: string;
-                limit: number;
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-                numCandidates?: number | undefined;
-            };
-        }, {
-            $vectorSearch: {
-                path: string;
-                index: string;
-                queryVector: string | number[];
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                exact?: boolean | undefined;
-                numCandidates?: number | undefined;
-                limit?: number | undefined;
-                embeddingParameters?: {
-                    outputDimension?: "256" | "512" | "1024" | "2048" | "4096" | undefined;
-                    outputDtype?: "binary" | "float" | "int8" | "uint8" | "ubinary" | undefined;
-                    model?: "voyage-3-large" | "voyage-3.5" | "voyage-3.5-lite" | "voyage-code-3" | undefined;
-                } | undefined;
-            } | {
-                query: {
-                    text: string;
-                };
-                path: string;
-                index: string;
-                filter?: {
-                    [x: string]: any;
-                } | undefined;
-                exact?: boolean | undefined;
-                model?: "voyage-code-3" | "voyage-4" | "voyage-4-large" | "voyage-4-lite" | undefined;
-                numCandidates?: number | undefined;
-                limit?: number | undefined;
-            };
-        }>, z.AnyZodObject]>, "many">;
-        database: z.ZodString;
+                }, z.core.$strip>;
+                model: z.ZodOptional<z.ZodEnum<{
+                    "voyage-4": "voyage-4";
+                    "voyage-4-large": "voyage-4-large";
+                    "voyage-4-lite": "voyage-4-lite";
+                    "voyage-code-3": "voyage-code-3";
+                }>>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
         collection: z.ZodString;
+        database: z.ZodString;
     };
     static operationType: OperationType;
     protected execute({ database, collection, pipeline, responseBytesLimit }: ToolArgs<typeof this.argsShape>, { signal }: ToolExecutionContext): Promise<CallToolResult>;
     private safeCloseCursor;
     private assertOnlyUsesPermittedStages;
     private countAggregationResultDocuments;
-    private replaceRawValuesWithEmbeddingsIfNecessary;
     private isVectorSearchIndexUsed;
     private generateMessage;
-    protected resolveTelemetryMetadata(args: ToolArgs<typeof this.argsShape>, { result }: {
-        result: CallToolResult;
-    }): ConnectionMetadata | AutoEmbeddingsUsageMetadata;
     private isSearchStage;
     private isWriteStage;
 }

package/dist/cjs/tools/mongodb/read/aggregate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,EAAmB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAcnF,OAAO,KAAK,EAAE,2BAA2B,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEnG,eAAO,MAAM,mCAAmC,kpEAwB/C,CAAC;AAIF,eAAO,MAAM,gBAAgB,GAAI,qBAAqB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAK9C,CAAC;AAEhB,qBAAa,aAAc,SAAQ,eAAe;IAC9C,MAAM,CAAC,QAAQ,SAAe;IACvB,WAAW,SAAqD;IAChE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOd;IACF,MAAM,CAAC,aAAa,EAAE,aAAa,CAAU;cAE7B,OAAO,CACnB,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,kBAAkB,EAAE,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,EACvF,EAAE,MAAM,EAAE,EAAE,oBAAoB,GACjC,OAAO,CAAC,cAAc,CAAC;YA8HZ,eAAe;YAYf,6BAA6B;YAgC7B,+BAA+B;YAmC/B,yCAAyC;YAgFzC,uBAAuB;IAmCrC,OAAO,CAAC,eAAe;IA6BvB,SAAS,CAAC,wBAAwB,CAC9B,IAAI,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,EACrC,EAAE,MAAM,EAAE,EAAE;QAAE,MAAM,EAAE,cAAc,CAAA;KAAE,GACvC,kBAAkB,GAAG,2BAA2B;IAyBnD,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;CAGvB"}
+{"version":3,"file":"aggregate.d.ts","sourceRoot":"","sources":["../../../../../src/tools/mongodb/read/aggregate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE,OAAO,EAAqB,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAenF,eAAO,MAAM,mCAAmC,glEAwB/C,CAAC;AAEF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEzB,CAAC;AAEF,qBAAa,aAAc,SAAQ,eAAe;IAC9C,MAAM,CAAC,QAAQ,SAAe;IACvB,WAAW,SAAqD;IAChE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOd;IACF,MAAM,CAAC,aAAa,EAAE,aAAa,CAAU;cAE7B,OAAO,CACnB,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,kBAAkB,EAAE,EAAE,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,EACvF,EAAE,MAAM,EAAE,EAAE,oBAAoB,GACjC,OAAO,CAAC,cAAc,CAAC;YAyHZ,eAAe;YAYf,6BAA6B;YAgC7B,+BAA+B;YAuC/B,uBAAuB;IAqCrC,OAAO,CAAC,eAAe;IA6BvB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,YAAY;CAGvB"}

package/dist/cjs/tools/mongodb/read/aggregate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AggregateTool = exports.getAggregateArgs = exports.pipelineDescriptionWithVectorSearch = void 0;
+exports.AggregateTool = exports.AggregateArgs = exports.pipelineDescriptionWithVectorSearch = void 0;
 const zod_1 = require("zod");
 const mongodbTool_js_1 = require("../mongodbTool.js");
 const tool_js_1 = require("../../tool.js");
@@ -10,7 +10,7 @@ const errors_js_1 = require("../../../common/errors.js");
 const collectCursorUntilMaxBytes_js_1 = require("../../../helpers/collectCursorUntilMaxBytes.js");
 const operationWithFallback_js_1 = require("../../../helpers/operationWithFallback.js");
 const constants_js_1 = require("../../../helpers/constants.js");
-const logger_js_1 = require("../../../common/logger.js");
+const index_js_1 = require("../../../common/logging/index.js");
 const mongodbSchemas_js_1 = require("../mongodbSchemas.js");
 const assertVectorSearchFilterFieldsAreIndexed_js_1 = require("../../../helpers/assertVectorSearchFilterFieldsAreIndexed.js");
 exports.pipelineDescriptionWithVectorSearch = `\
@@ -21,7 +21,7 @@ If the user has asked for lexical/Atlas search, use \`$search\` instead of \`$te
 - **Index Type Detection:**
   Use the collection-indexes tool to determine if the target field has a classic vector index (type: 'vector') or an auto-embed index (type: 'autoEmbed').
 - **Classic Vector Search (type: 'vector'):**
-  Use 'queryVector' with embeddings as an array of numbers, or as a string with 'embeddingParameters' to generate embeddings.
+  Use 'queryVector' with embeddings as an array of numbers.
 - **Auto-Embed Vector Search (type: 'autoEmbed'):**
   Use 'query' - MongoDB automatically generates embeddings at query time. Do NOT use 'queryVector' or 'embeddingParameters' for auto-embed indexes.
 - **Unset embeddings:**
@@ -38,20 +38,16 @@ If the user has asked for lexical/Atlas search, use \`$search\` instead of \`$te
 - Include the index name, unless you know for a fact there's a default index. If unsure, use the collection-indexes tool to determine the index name.
 - The \`$search\` stage supports multiple operators, such as 'autocomplete', 'text', 'geoWithin', and others. Choose the approprate operator based on the user's query. If unsure of the exact syntax, consult the MongoDB Atlas Search documentation, which can be found here: https://www.mongodb.com/docs/atlas/atlas-search/operators-and-collectors/
 `;
-const genericPipelineDescription = "An array of aggregation stages to execute.";
-const getAggregateArgs = (vectorSearchEnabled) => ({
-    pipeline: zod_1.z
-        .array(vectorSearchEnabled ? zod_1.z.union([mongodbSchemas_js_1.VectorSearchStage, mongodbSchemas_js_1.AnyAggregateStage]) : mongodbSchemas_js_1.AnyAggregateStage)
-        .describe(vectorSearchEnabled ? exports.pipelineDescriptionWithVectorSearch : genericPipelineDescription),
-});
-exports.getAggregateArgs = getAggregateArgs;
+exports.AggregateArgs = {
+    pipeline: zod_1.z.array(zod_1.z.union([mongodbSchemas_js_1.VectorSearchStage, mongodbSchemas_js_1.AnyAggregateStage])).describe(exports.pipelineDescriptionWithVectorSearch),
+};
 class AggregateTool extends mongodbTool_js_1.MongoDBToolBase {
     constructor() {
         super(...arguments);
         this.description = "Run an aggregation against a MongoDB collection";
         this.argsShape = {
-            ...mongodbTool_js_1.DbOperationArgs,
-            ...(0, exports.getAggregateArgs)(this.isFeatureEnabled("search")),
+            ...mongodbTool_js_1.CollOperationArgs,
+            ...exports.AggregateArgs,
             responseBytesLimit: zod_1.z.number().optional().default(constants_js_1.ONE_MB).describe(`\
 The maximum number of bytes to return in the response. This value is capped by the server's configured maxBytesPerQuery and cannot be exceeded. \
 Note to LLM: If the entire aggregation result is required, use the "export" tool instead of increasing this limit.\
@@ -86,7 +82,7 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
                             explainCallback: async () => {
                                 return provider
                                     .aggregate(database, collection, pipeline, {
-                                    signal,
+                                    ...this.getOperationOptions(signal),
                                 }, { writeConcern: undefined })
                                     .explain("queryPlanner");
                             },
@@ -96,14 +92,10 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
                     case "non-existent-index":
                         throw new errors_js_1.MongoDBError(errors_js_1.ErrorCodes.AtlasVectorSearchIndexNotFound, `Could not find an index with name "${indexName}" in namespace "${database}.${collection}".`);
                     case "valid-index":
-                    // nothing to do, everything is correct so ready to run the query
+                        // nothing to do, everything is correct so ready to run the query
+                        break;
                 }
             }
-            pipeline = await this.replaceRawValuesWithEmbeddingsIfNecessary({
-                database,
-                collection,
-                pipeline,
-            });
             let successMessage;
             let documents;
             if (pipeline.some((stage) => this.isWriteStage(stage))) {
@@ -120,7 +112,7 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
                     cappedResultsPipeline.push({ $limit: this.config.maxDocumentsPerQuery });
                 }
                 aggregationCursor = provider.aggregate(database, collection, cappedResultsPipeline, {
-                    signal,
+                    ...this.getOperationOptions(signal),
                 });
                 const [totalDocuments, cursorResults] = await Promise.all([
                     this.countAggregationResultDocuments({
@@ -170,7 +162,7 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
         }
         catch (error) {
             this.session.logger.warning({
-                id: logger_js_1.LogId.mongodbCursorCloseError,
+                id: index_js_1.LogId.mongodbCursorCloseError,
                 context: "aggregate tool",
                 message: `Error when closing the cursor - ${error instanceof Error ? error.message : String(error)}`,
             });
@@ -208,7 +200,9 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
                 .aggregate(database, collection, resultsCountAggregation, {
                 signal: abortSignal,
             })
-                .maxTimeMS(constants_js_1.AGG_COUNT_MAX_TIME_MS_CAP)
+                .maxTimeMS(this.config.maxTimeMS !== undefined
+                ? Math.min(this.config.maxTimeMS, constants_js_1.AGG_COUNT_MAX_TIME_MS_CAP)
+                : constants_js_1.AGG_COUNT_MAX_TIME_MS_CAP)
                 .toArray();
             const documentWithCount = aggregationResults.length === 1 ? aggregationResults[0] : undefined;
             const totalDocuments = documentWithCount &&
@@ -220,54 +214,6 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
             return totalDocuments;
         }, undefined);
     }
-    async replaceRawValuesWithEmbeddingsIfNecessary({ database, collection, pipeline, }) {
-        for (const stage of pipeline) {
-            if ("$vectorSearch" in stage) {
-                const { $vectorSearch: vectorSearchStage } = stage;
-                // If the stage is using 'query' field (auto-embed indexes) then
-                // it is targeting an `autoEmbed` index. In this case, we don't
-                // need to generate embeddings for the query because MongoDB is
-                // configured to handle the embeddings generation automatically.
-                if ("query" in vectorSearchStage) {
-                    continue;
-                }
-                // If queryVector is already an array, no embedding generation
-                // needed.
-                if (Array.isArray(vectorSearchStage.queryVector)) {
-                    continue;
-                }
-                // At this point, queryVector must be a string for which we need
-                // to generate embeddings.
-                if (!vectorSearchStage.queryVector) {
-                    throw new errors_js_1.MongoDBError(errors_js_1.ErrorCodes.AtlasVectorSearchInvalidQuery, "Either 'queryVector' (for classic vector indexes) or 'query' (for auto-embed indexes) must be provided in $vectorSearch. Use the collection-indexes tool to verify which type of index the target field has.");
-                }
-                if (!vectorSearchStage.embeddingParameters) {
-                    throw new errors_js_1.MongoDBError(errors_js_1.ErrorCodes.AtlasVectorSearchInvalidQuery, "embeddingParameters is mandatory when providing queryVector as a string for classic vector search indexes (type: 'vector'). If the target field has an auto-embed index (type: 'autoEmbed'), use 'query' instead of 'queryVector'. Use the collection-indexes tool to verify the index type.");
-                }
-                const embeddingParameters = vectorSearchStage.embeddingParameters;
-                delete vectorSearchStage.embeddingParameters;
-                await this.session.vectorSearchEmbeddingsManager.assertVectorSearchIndexExists({
-                    database,
-                    collection,
-                    path: vectorSearchStage.path,
-                });
-                const [embeddings] = await this.session.vectorSearchEmbeddingsManager.generateEmbeddings({
-                    rawValues: [vectorSearchStage.queryVector],
-                    embeddingParameters,
-                    inputType: "query",
-                });
-                if (!embeddings) {
-                    throw new errors_js_1.MongoDBError(errors_js_1.ErrorCodes.AtlasVectorSearchInvalidQuery, "Failed to generate embeddings for the query vector.");
-                }
-                // $vectorSearch.queryVector can be a BSON.Binary: that it's not either number or an array.
-                // It's not exactly valid from the LLM perspective (they can't provide binaries).
-                // That's why we overwrite the stage in an untyped way, as what we expose and what LLMs can use is different.
-                vectorSearchStage.queryVector = embeddings;
-            }
-        }
-        await this.session.vectorSearchEmbeddingsManager.assertFieldsHaveCorrectEmbeddings({ database, collection }, pipeline);
-        return pipeline;
-    }
     async isVectorSearchIndexUsed({ database, collection, pipeline, }) {
         // check if the pipeline contains a $vectorSearch stage
         let usesVectorSearch = false;
@@ -283,11 +229,13 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
         if (!usesVectorSearch) {
             return ["not-vector-search-query"];
         }
-        const indexExists = await this.session.vectorSearchEmbeddingsManager.indexExists({
-            database,
-            collection,
-            indexName,
-        });
+        const isSearchSupported = await this.session.isSearchSupported();
+        let indexExists = false;
+        if (isSearchSupported) {
+            const provider = await this.ensureConnected();
+            const indexes = await provider.getSearchIndexes(database, collection, indexName);
+            indexExists = indexes.length >= 1;
+        }
         return [indexExists ? "valid-index" : "non-existent-index", indexName];
     }
     generateMessage({ aggResultsCount, documents, appliedLimits, }) {
@@ -305,25 +253,6 @@ Note to LLM: If the entire aggregation result is required, use the "export" tool
         }
         return message;
     }
-    resolveTelemetryMetadata(args, { result }) {
-        const [maybeVectorStage] = args.pipeline;
-        const usesVectorSearch = maybeVectorStage !== null && maybeVectorStage instanceof Object && "$vectorSearch" in maybeVectorStage;
-        if (usesVectorSearch &&
-            "embeddingParameters" in maybeVectorStage["$vectorSearch"] &&
-            this.config.voyageApiKey) {
-            return {
-                ...super.resolveTelemetryMetadata(args, { result }),
-                embeddingsGeneratedBy: "mcp",
-            };
-        }
-        if (usesVectorSearch && "query" in maybeVectorStage["$vectorSearch"]) {
-            return {
-                ...super.resolveTelemetryMetadata(args, { result }),
-                embeddingsGeneratedBy: "mongot",
-            };
-        }
-        return super.resolveTelemetryMetadata(args, { result });
-    }
     isSearchStage(stage) {
         return "$vectorSearch" in stage || "$search" in stage || "$searchMeta" in stage;
     }