fix: removes default limit from find tool schema

This commit removes default limit from the find tool schema because now
we have a configurable max limit of the documents allowed to be sent per
query.

Author: himanshusinghs

src/common/config.ts

@@ -182,8 +182,8 @@ export const defaultUserConfig: UserConfig = {
     idleTimeoutMs: 600000, // 10 minutes
     notificationTimeoutMs: 540000, // 9 minutes
     httpHeaders: {},
-    maxDocumentsPerQuery: 50,
-    maxBytesPerQuery: 1 * 1000 * 1000, // 1 mb
+    maxDocumentsPerQuery: 10, // By default, we only fetch a maximum 10 documents per query / aggregation
+    maxBytesPerQuery: 1 * 1000 * 1000, // By default, we only return ~1 mb of data per query / aggregation
 };
 
 export const config = setupUserConfig({

src/tools/mongodb/read/export.ts

@@ -24,7 +24,7 @@ export class ExportTool extends MongoDBToolBase {
                         arguments: z
                             .object({
                                 ...FindArgs,
-                                limit: FindArgs.limit.removeDefault(),
+                                limit: FindArgs.limit,
                             })
                             .describe("The arguments for 'find' operation."),
                     }),

src/tools/mongodb/read/find.ts

@@ -21,7 +21,7 @@ export const FindArgs = {
         .passthrough()
         .optional()
         .describe("The projection, matching the syntax of the projection argument of db.collection.find()"),
-    limit: z.number().optional().default(10).describe("The maximum number of documents to return"),
+    limit: z.number().optional().describe("The maximum number of documents to return"),
     sort: z
         .object({})
         .catchall(z.custom<SortDirection>())
@@ -61,18 +61,21 @@ export class FindTool extends MongoDBToolBase {
                 });
             }
 
-            const appliedLimit = Math.min(limit, this.config.maxDocumentsPerQuery);
+            const limitOnFindCursor = Math.min(limit ?? Number.POSITIVE_INFINITY, this.config.maxDocumentsPerQuery);
             findCursor = provider.find(database, collection, filter, {
                 projection,
-                limit: appliedLimit,
+                limit: limitOnFindCursor,
                 sort,
-                batchSize: appliedLimit,
+                batchSize: limitOnFindCursor,
             });
 
             const [queryResultsCount, documents] = await Promise.all([
                 operationWithFallback(
                     () =>
                         provider.countDocuments(database, collection, filter, {
+                            // We should be counting documents that the original
+                            // query would have yielded which is why we don't
+                            // use `limitOnFindCursor` calculated above.
                             limit,
                             maxTimeMS: QUERY_COUNT_MAX_TIME_MS_CAP,
                         }),

tests/integration/tools/mongodb/read/find.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { Document, Collection } from "mongodb";
 import {
     getResponseContent,
@@ -228,37 +228,38 @@ describeWithMongoDB("find tool", (integration) => {
 describeWithMongoDB(
     "find tool with configured max documents per query",
     (integration) => {
+        beforeEach(async () => {
+            await freshInsertDocuments({
+                collection: integration.mongoClient().db(integration.randomDbName()).collection("foo"),
+                count: 1000,
+            });
+        });
+
+        afterEach(() => {
+            vi.resetAllMocks();
+        });
+
         describe("when the provided limit is lower than the configured max limit", () => {
             it("should return documents limited to the provided limit", async () => {
-                await freshInsertDocuments({
-                    collection: integration.mongoClient().db(integration.randomDbName()).collection("foo"),
-                    count: 1000,
-                });
                 await integration.connectMcpClient();
                 const response = await integration.mcpClient().callTool({
                     name: "find",
                     arguments: {
                         database: integration.randomDbName(),
                         collection: "foo",
                         filter: {},
-                        // default is 10
-                        limit: undefined,
+                        limit: 8,
                     },
                 });
 
                 const content = getResponseContent(response);
-                expect(content).toContain(`Query on collection "foo" resulted in 10 documents.`);
-                expect(content).toContain(`Returning 10 documents while respecting the applied limits.`);
+                expect(content).toContain(`Query on collection "foo" resulted in 8 documents.`);
+                expect(content).toContain(`Returning 8 documents while respecting the applied limits.`);
             });
         });
 
         describe("when the provided limit is larger than the configured max limit", () => {
             it("should return documents limited to the configured max limit", async () => {
-                await freshInsertDocuments({
-                    collection: integration.mongoClient().db(integration.randomDbName()).collection("foo"),
-                    count: 1000,
-                });
-
                 await integration.connectMcpClient();
                 const response = await integration.mcpClient().callTool({
                     name: "find",
@@ -272,17 +273,13 @@ describeWithMongoDB(
 
                 const content = getResponseContent(response);
                 expect(content).toContain(`Query on collection "foo" resulted in 1000 documents.`);
-                expect(content).toContain(`Returning 20 documents while respecting the applied limits.`);
+                expect(content).toContain(`Returning 10 documents while respecting the applied limits.`);
             });
         });
 
         describe("when counting documents exceed the configured count maxTimeMS", () => {
-            it("should abort discard count operation and respond with indeterminable count", async () => {
+            it("should abort count operation and respond with indeterminable count", async () => {
                 vi.spyOn(constants, "QUERY_COUNT_MAX_TIME_MS_CAP", "get").mockReturnValue(0.1);
-                await freshInsertDocuments({
-                    collection: integration.mongoClient().db(integration.randomDbName()).collection("foo"),
-                    count: 1000,
-                });
                 await integration.connectMcpClient();
                 const response = await integration.mcpClient().callTool({
                     name: "find",
@@ -293,22 +290,23 @@ describeWithMongoDB(
 
                 const docs = getDocsFromUntrustedContent(content);
                 expect(docs.length).toEqual(10);
-                vi.resetAllMocks();
             });
         });
     },
-    () => ({ ...defaultTestConfig, maxDocumentsPerQuery: 20 })
+    () => ({ ...defaultTestConfig, maxDocumentsPerQuery: 10 })
 );
 
 describeWithMongoDB(
     "find tool with configured max bytes per query",
     (integration) => {
+        beforeEach(async () => {
+            await freshInsertDocuments({
+                collection: integration.mongoClient().db(integration.randomDbName()).collection("foo"),
+                count: 1000,
+            });
+        });
         describe("when the provided maxBytesPerQuery is hit", () => {
             it("should return only the documents that could fit in maxBytesPerQuery limit", async () => {
-                await freshInsertDocuments({
-                    collection: integration.mongoClient().db(integration.randomDbName()).collection("foo"),
-                    count: 1000,
-                });
                 await integration.connectMcpClient();
                 const response = await integration.mcpClient().callTool({
                     name: "find",