mcp-mongo-server 3.0.2 → 3.2.0

package/build/index.js

@@ -7,334 +7,1313 @@ import { createMcpHandler } from "@modelcontextprotocol/server";
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
 import { createMcpExpressApp } from "@modelcontextprotocol/express";
 
-// src/mongo.ts
+// src/connections.ts
+import { randomUUID } from "crypto";
+import { ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";
 import { MongoClient } from "mongodb";
-async function connectToMongoDB(url, readOnly) {
-  try {
-    const client = new MongoClient(url);
-    await client.connect();
-    const db = client.db();
-    console.warn(`Connected to MongoDB database: ${db.databaseName}`);
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+var Connections = class {
+  cursorScope = randomUUID();
+  named;
+  entries = /* @__PURE__ */ new Map();
+  closing;
+  constructor(legacyUri, configuration, readOnly) {
+    this.named = configuration !== void 0;
+    let config = {};
+    if (configuration !== void 0) {
+      try {
+        config = JSON.parse(configuration);
+      } catch {
+        throw new Error("MCP_MONGODB_CONNECTIONS must be valid JSON");
+      }
+    }
+    if (!isRecord(config))
+      throw new Error("MCP_MONGODB_CONNECTIONS must be an object");
+    if (legacyUri && Object.hasOwn(config, "default")) {
+      throw new Error("The legacy URI and named default connection conflict");
+    }
+    const entries = legacyUri ? { ...config, default: { uri: legacyUri } } : config;
+    if (!Object.hasOwn(entries, "default"))
+      throw new Error("A default MongoDB connection is required");
+    for (const [id, entry] of Object.entries(entries)) {
+      if (!/^[A-Za-z0-9_-]+$/.test(id))
+        throw new Error("Invalid connection ID");
+      if (!isRecord(entry) || Object.keys(entry).some(
+        (key) => !["uri", "databases", "readOnly"].includes(key)
+      )) {
+        throw new Error(`Invalid configuration for connection '${id}'`);
+      }
+      const { uri, databases, readOnly: localReadOnly } = entry;
+      if (typeof uri !== "string" || !/^mongodb(?:\+srv)?:\/\//.test(uri)) {
+        throw new Error(`Invalid MongoDB URI for connection '${id}'`);
+      }
+      if (localReadOnly !== void 0 && typeof localReadOnly !== "boolean") {
+        throw new Error(`Invalid readOnly setting for connection '${id}'`);
+      }
+      let client;
+      const query = uri.indexOf("?");
+      const uriOptions = new URLSearchParams(
+        query < 0 ? "" : uri.slice(query + 1)
+      );
+      const hasSelectionTimeout = [...uriOptions.keys()].some(
+        (key) => key.toLowerCase() === "serverselectiontimeoutms"
+      );
+      const selectionTimeout = this.named && !hasSelectionTimeout ? 5e3 : void 0;
+      try {
+        client = new MongoClient(uri, {
+          serverSelectionTimeoutMS: selectionTimeout
+        });
+      } catch {
+        throw new Error(`Invalid MongoDB URI for connection '${id}'`);
+      }
+      const defaultDatabase = client.db().databaseName;
+      if (databases !== void 0 && (!Array.isArray(databases) || !databases.includes(defaultDatabase) || databases.some(
+        (name) => typeof name !== "string" || !name.trim() || /[/\\. "$]/.test(name) || name.includes("\0")
+      ))) {
+        throw new Error(`Invalid database allowlist for connection '${id}'`);
+      }
+      this.entries.set(id, {
+        connectionId: id,
+        uri,
+        selectionTimeout,
+        client,
+        defaultDatabase,
+        databases: databases === void 0 ? [defaultDatabase] : [...new Set(databases)].sort(),
+        readOnly: readOnly || localReadOnly === true
+      });
+    }
+  }
+  connection(id = "default") {
+    const entry = typeof id === "string" ? this.entries.get(id) : void 0;
+    if (!entry) throw new Error("Unknown or invalid MongoDB connection ID");
+    return entry;
+  }
+  list() {
+    return [...this.entries.keys()].sort().map((id) => {
+      const { connectionId, defaultDatabase, readOnly } = this.connection(id);
+      return { connectionId, defaultDatabase, readOnly };
+    });
+  }
+  allowedDatabases(id) {
+    return this.connection(id).databases;
+  }
+  async resolve({ connectionId, database } = {}) {
+    const entry = this.connection(connectionId);
+    const name = database === void 0 ? entry.defaultDatabase : database;
+    if (typeof name !== "string" || !entry.databases.includes(name)) {
+      throw new Error(
+        `Database is invalid or not allowed on connection '${entry.connectionId}'`
+      );
+    }
+    if (this.closing) throw new Error("MongoDB connections are shutting down");
+    if (!entry.pending) {
+      const client2 = entry.client ?? new MongoClient(entry.uri, {
+        serverSelectionTimeoutMS: entry.selectionTimeout
+      });
+      entry.client = client2;
+      entry.pending = client2.connect().catch(async () => {
+        await client2.close().catch(() => void 0);
+        entry.client = void 0;
+        entry.pending = void 0;
+        throw new Error(
+          `Failed to connect to MongoDB connection '${entry.connectionId}'`
+        );
+      });
+    }
+    const client = await entry.pending;
     return {
       client,
-      db,
-      isConnected: true,
-      isReadOnlyMode: readOnly
-    };
-  } catch (error) {
-    console.error("Failed to connect to MongoDB:", error);
-    return {
-      client: null,
-      db: null,
-      isConnected: false,
-      isReadOnlyMode: readOnly
+      db: client.db(name),
+      isReadOnlyMode: entry.readOnly,
+      connectionId: entry.connectionId
     };
   }
+  async listDatabases(connectionId) {
+    const { db } = await this.resolve({ connectionId });
+    const allowed = this.allowedDatabases(connectionId);
+    const { databases } = await db.admin().listDatabases({
+      nameOnly: true,
+      authorizedDatabases: true,
+      filter: { name: { $in: [...allowed] } }
+    });
+    return databases.map(({ name }) => name).filter((name) => allowed.includes(name)).sort();
+  }
+  async close() {
+    this.closing ??= Promise.allSettled(
+      [...this.entries.values()].map(async ({ client, pending }) => {
+        await pending?.catch(() => void 0);
+        await client?.close();
+      })
+    ).then(() => void 0);
+    await this.closing;
+  }
+};
+function resourceSelectors(uri) {
+  let url;
+  try {
+    url = new URL(uri);
+    if (url.protocol !== "mongodb:") throw new Error("Invalid scheme");
+    decodeURIComponent(url.search);
+  } catch {
+    throw new ProtocolError(
+      ProtocolErrorCode.InvalidParams,
+      "Invalid MongoDB resource URI"
+    );
+  }
+  const selectors = {};
+  for (const key of ["connectionId", "database"]) {
+    const values = url.searchParams.getAll(key);
+    if (values.length > 1) {
+      throw new ProtocolError(
+        ProtocolErrorCode.InvalidParams,
+        `Duplicate resource selector '${key}'`
+      );
+    }
+    if (values.length === 1) selectors[key] = values[0];
+  }
+  return selectors;
+}
+
+// src/query-limits.ts
+function readQueryLimits(env) {
+  function positiveInteger(key) {
+    const raw = env[key];
+    if (raw === void 0) return void 0;
+    const value = Number(raw);
+    if (!/^\d+$/.test(raw) || !Number.isSafeInteger(value) || value <= 0) {
+      throw new Error(`${key} must be a positive integer`);
+    }
+    return value;
+  }
+  const bytes = positiveInteger("MCP_MONGODB_MAX_RESULT_BYTES");
+  if (bytes === 1) {
+    throw new Error("MCP_MONGODB_MAX_RESULT_BYTES must be at least 2 bytes");
+  }
+  return {
+    documents: positiveInteger("MCP_MONGODB_MAX_RESULT_DOCUMENTS"),
+    bytes,
+    timeoutMS: positiveInteger("MCP_MONGODB_QUERY_TIMEOUT_MS")
+  };
+}
+async function readResultPage(cursor, limits, pageSize = Infinity, signal) {
+  const results = [];
+  const documentCap = limits.documents ?? Infinity;
+  const maxRows = Math.min(documentCap, pageSize);
+  let bytes = 2;
+  try {
+    while (true) {
+      signal?.throwIfAborted();
+      const row = await cursor.next();
+      signal?.throwIfAborted();
+      if (row === null) return { results, hasMore: false };
+      if (results.length === maxRows) {
+        return {
+          results,
+          hasMore: true,
+          ...documentCap < pageSize ? { truncated: "documents" } : {}
+        };
+      }
+      if (limits.bytes !== void 0) {
+        bytes += Buffer.byteLength(JSON.stringify(row), "utf8") + (results.length ? 1 : 0);
+        if (bytes > limits.bytes) {
+          if (!results.length) {
+            throw new Error(
+              "First result exceeds the byte limit. Use a narrower projection or pipeline."
+            );
+          }
+          return { results, hasMore: true, truncated: "bytes" };
+        }
+      }
+      results.push(row);
+    }
+  } finally {
+    await cursor.close();
+  }
 }
 
 // src/server.ts
-import { Server } from "@modelcontextprotocol/server";
+import {
+  ProtocolError as ProtocolError4,
+  ProtocolErrorCode as ProtocolErrorCode4,
+  Server
+} from "@modelcontextprotocol/server";
 
 // src/schemas/call.ts
-import { ProtocolError, ProtocolErrorCode } from "@modelcontextprotocol/server";
+import { ProtocolError as ProtocolError3, ProtocolErrorCode as ProtocolErrorCode3 } from "@modelcontextprotocol/server";
+import { ObjectId as ObjectId2 } from "mongodb";
+
+// src/schemas/resource.ts
+import {
+  ProtocolError as ProtocolError2,
+  ProtocolErrorCode as ProtocolErrorCode2
+} from "@modelcontextprotocol/server";
 import { ObjectId } from "mongodb";
-var COLLECTION_OPERATIONS = [
-  "query",
-  "aggregate",
-  "update",
-  "insert",
-  "createIndex",
-  "count"
-];
-var WRITE_OPERATIONS = ["update", "insert", "createIndex"];
-var MAX_OBJECT_DEPTH = 100;
-var WRITE_AGG_STAGES = /* @__PURE__ */ new Set(["$out", "$merge"]);
-var SERVER_JS_AGG_OPERATORS = /* @__PURE__ */ new Set([
-  "$function",
-  "$accumulator",
-  "$where"
-]);
-var READONLY_FORBIDDEN_AGG_OPERATORS = /* @__PURE__ */ new Set([
-  ...WRITE_AGG_STAGES,
-  ...SERVER_JS_AGG_OPERATORS
-]);
-function findAggOperator(value, operators, depth = 0) {
-  if (depth > MAX_OBJECT_DEPTH) {
-    throw new Error(
-      `Object nesting exceeds the maximum depth of ${MAX_OBJECT_DEPTH}`
+
+// src/utils/pagination.ts
+var DEFAULT_PAGE_SIZE = 20;
+function encodeCursor(offset) {
+  const data = { offset };
+  return Buffer.from(JSON.stringify(data)).toString("base64");
+}
+function decodeCursor(cursor) {
+  if (!cursor) return 0;
+  try {
+    const data = JSON.parse(
+      Buffer.from(cursor, "base64").toString("utf-8")
     );
+    return typeof data.offset === "number" && data.offset >= 0 ? data.offset : 0;
+  } catch {
+    return 0;
   }
+}
+function paginate(items, cursor, pageSize = DEFAULT_PAGE_SIZE) {
+  const offset = decodeCursor(cursor);
+  const page = items.slice(offset, offset + pageSize);
+  const nextOffset = offset + pageSize;
+  const nextCursor = nextOffset < items.length ? encodeCursor(nextOffset) : void 0;
+  return { items: page, nextCursor };
+}
+
+// src/schemas/resource.ts
+function detectMongoType(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (value instanceof ObjectId) return "ObjectId";
+  if (value instanceof Date) return "Date";
   if (Array.isArray(value)) {
-    for (const item of value) {
-      const found = findAggOperator(item, operators, depth + 1);
-      if (found) return found;
+    if (value.length === 0) return "Array";
+    const elementTypes = new Set(value.map((item) => detectMongoType(item)));
+    if (elementTypes.size === 1) {
+      return `Array<${Array.from(elementTypes)[0]}>`;
     }
-    return null;
+    return "Array<mixed>";
   }
-  if (value && typeof value === "object") {
-    for (const [key, nested] of Object.entries(value)) {
-      if (operators.has(key)) {
-        return key;
+  if (typeof value === "object") {
+    return "Document";
+  }
+  return typeof value;
+}
+function inferSchemaFromSamples(documents) {
+  if (!documents || documents.length === 0) {
+    return { fields: [] };
+  }
+  const fieldMap = /* @__PURE__ */ new Map();
+  for (const doc of documents) {
+    for (const [key, value] of Object.entries(doc)) {
+      if (!fieldMap.has(key)) {
+        fieldMap.set(key, {
+          name: key,
+          types: /* @__PURE__ */ new Set([detectMongoType(value)]),
+          nullable: false,
+          // Store sample values for complex types
+          samples: [value]
+        });
+      } else {
+        const fieldInfo = fieldMap.get(key);
+        fieldInfo.types.add(detectMongoType(value));
+        if (fieldInfo.samples.length < 3 && !fieldInfo.samples.some(
+          (sample) => JSON.stringify(sample) === JSON.stringify(value)
+        )) {
+          fieldInfo.samples.push(value);
+        }
       }
-      const found = findAggOperator(nested, operators, depth + 1);
-      if (found) return found;
     }
   }
-  return null;
-}
-function assertNoServerJs(value) {
-  const operator = findAggOperator(value, SERVER_JS_AGG_OPERATORS);
-  if (operator) {
-    throw new Error(
-      `Server-side JavaScript operator '${operator}' is disabled by the current server policy.`
-    );
+  for (const doc of documents) {
+    for (const [key] of fieldMap.entries()) {
+      if (!(key in doc)) {
+        const fieldInfo = fieldMap.get(key);
+        fieldInfo.nullable = true;
+      }
+    }
   }
-}
-function findCrossDbTarget(pipeline, connectedDb) {
-  const foreignDb = (target) => {
-    if (target && typeof target === "object" && "db" in target) {
-      const db = target.db;
-      if (typeof db === "string" && db && db !== connectedDb) return db;
+  for (const [key, fieldInfo] of fieldMap.entries()) {
+    if (fieldInfo.types.has("Document")) {
+      const nestedDocs = documents.filter(
+        (doc) => doc[key] && typeof doc[key] === "object" && !Array.isArray(doc[key])
+      ).map((doc) => doc[key]);
+      if (nestedDocs.length > 0) {
+        fieldInfo.nestedSchema = inferSchemaFromSamples(nestedDocs);
+      }
     }
-    return null;
-  };
-  for (const stage of pipeline) {
-    if (!stage || typeof stage !== "object") continue;
-    const s = stage;
-    const out = foreignDb(s.$out);
-    if (out) return out;
-    const merge = s.$merge;
-    const mergeInto = foreignDb(merge?.into ?? s.$merge);
-    if (mergeInto) return mergeInto;
-    const lookup = s.$lookup;
-    const lookupFrom = foreignDb(lookup?.from);
-    if (lookupFrom) return lookupFrom;
   }
-  return null;
+  const fields = Array.from(fieldMap.values()).map((fieldInfo) => {
+    const result = {
+      name: fieldInfo.name,
+      types: Array.from(fieldInfo.types),
+      nullable: fieldInfo.nullable,
+      prevalence: `${Math.round(
+        documents.filter((doc) => fieldInfo.name in doc).length / documents.length * 100
+      )}%`,
+      examples: []
+    };
+    if (fieldInfo.nestedSchema) {
+      result.nestedSchema = fieldInfo.nestedSchema;
+    }
+    const sampleValues = fieldInfo.samples.map((sample) => {
+      if (sample instanceof ObjectId) return sample.toString();
+      if (sample instanceof Date) return sample.toISOString();
+      if (typeof sample === "object") {
+        return Array.isArray(sample) ? "[...]" : "{...}";
+      }
+      return sample;
+    });
+    result.examples = sampleValues;
+    return result;
+  });
+  return { fields };
 }
-async function handleCallToolRequest({
+async function handleReadResourceRequest({
   request,
   client,
   db,
   isReadOnlyMode,
-  allowCrossDb = false,
-  allowServerJs = false,
-  signal
+  signal,
+  sendProgress
 }) {
-  const { name, arguments: args = {} } = request.params;
-  const operation = name;
-  const objectIdMode = args.objectIdMode || "auto";
-  const filteredArgs = {};
-  for (const [key, value] of Object.entries(args)) {
-    if (key !== "objectIdMode") {
-      filteredArgs[key] = value;
-    }
-  }
-  if (args.sort) {
-    args.sort = parseSort(args.sort);
-  }
-  Object.assign(args, filteredArgs);
-  validateOperation(operation);
+  let collectionName;
   try {
-    checkReadOnlyMode(operation, isReadOnlyMode);
-    let collection = null;
-    if (COLLECTION_OPERATIONS.includes(operation)) {
-      const collectionName = args.collection;
-      if (!collectionName) {
-        throw new Error(
-          `Collection name is required for '${operation}' operation`
-        );
-      }
-      collection = db.collection(collectionName);
-      validateCollection(collection);
+    const url = new URL(request.params.uri);
+    if (url.protocol !== "mongodb:") {
+      throw new ProtocolError2(
+        ProtocolErrorCode2.InvalidParams,
+        `Unsupported resource URI scheme '${url.protocol}': expected 'mongodb:'`
+      );
     }
-    signal?.throwIfAborted();
-    return await executeOperation(
-      operation,
-      collection,
-      db,
-      isReadOnlyMode,
-      allowCrossDb,
-      allowServerJs,
-      args,
-      objectIdMode,
-      signal
-    );
+    collectionName = decodeURIComponent(url.pathname.replace(/^\//, ""));
   } catch (error) {
-    if (error instanceof ProtocolError || signal?.aborted) {
-      throw error;
-    }
-    return toolExecutionError(
-      error instanceof Error ? error.message : "Unknown error"
+    if (error instanceof ProtocolError2) throw error;
+    throw new ProtocolError2(
+      ProtocolErrorCode2.InvalidParams,
+      `Invalid resource URI: ${request.params.uri}`
     );
   }
-}
-async function executeOperation(operation, collection, db, isReadOnlyMode, allowCrossDb, allowServerJs, args, objectIdMode, signal) {
-  switch (operation) {
-    case "query":
-      return handleQuery(
-        collection,
-        args,
-        objectIdMode,
-        allowServerJs && !isReadOnlyMode,
-        signal
-      );
-    case "aggregate":
-      return handleAggregate(
-        collection,
-        args,
-        objectIdMode,
-        isReadOnlyMode,
-        allowCrossDb,
-        allowServerJs,
-        signal
-      );
-    case "update":
-      return handleUpdate(collection, args, objectIdMode, allowServerJs, signal);
-    case "serverInfo":
-      return handleServerInfo(db, isReadOnlyMode, args, signal);
-    case "insert":
-      return handleInsert(collection, args, objectIdMode, signal);
-    case "createIndex":
-      return handleCreateIndex(collection, args, objectIdMode, signal);
-    case "count":
-      return handleCount(
-        collection,
-        args,
-        objectIdMode,
-        allowServerJs && !isReadOnlyMode,
-        signal
-      );
-    case "listCollections":
-      return handleListCollections(db, args, objectIdMode, signal);
-    case "convertTime":
-      return handleConvertTime(args);
-    default:
-      throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Unknown tool: ${operation}`);
-  }
-}
-function validateOperation(operation) {
-  const validOperations = [
-    "query",
-    "aggregate",
-    "update",
-    "serverInfo",
-    "insert",
-    "createIndex",
-    "count",
-    "listCollections",
-    "convertTime"
-  ];
-  if (!validOperations.includes(operation)) {
-    throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Unknown tool: ${operation}`);
-  }
-}
-function validateCollection(collection) {
-  if (!collection.collectionName) {
-    throw new Error("Collection name cannot be empty");
-  }
-  if (collection.collectionName.toLowerCase().startsWith("system.")) {
-    throw new Error("Access to system collections is not allowed");
-  }
-}
-function checkReadOnlyMode(operation, isReadOnlyMode) {
-  if (isReadOnlyMode && WRITE_OPERATIONS.includes(operation)) {
-    throw new Error(
-      `ReadonlyError: Operation '${operation}' is not allowed in read-only mode`
+  if (!collectionName) {
+    throw new ProtocolError2(
+      ProtocolErrorCode2.InvalidParams,
+      "Resource URI is missing a collection name"
     );
   }
-}
-function parseSort(sort) {
-  if (!sort) return null;
-  if (typeof sort !== "object" || sort === null || Array.isArray(sort)) {
-    return null;
+  if (collectionName.toLowerCase().startsWith("system.")) {
+    throw new ProtocolError2(
+      ProtocolErrorCode2.InvalidParams,
+      "Access to system collections is not allowed"
+    );
   }
-  const validSort = {};
-  for (const [key, value] of Object.entries(sort)) {
-    if (typeof value === "number" && (value === 1 || value === -1)) {
-      validSort[key] = value;
+  try {
+    const schema = await buildCollectionSchema(
+      db,
+      db.collection(collectionName),
+      signal,
+      sendProgress
+    );
+    return {
+      contents: [
+        {
+          uri: request.params.uri,
+          mimeType: "application/json",
+          text: JSON.stringify(schema, null, 2)
+        }
+      ]
+    };
+  } catch (error) {
+    signal?.throwIfAborted();
+    if (error instanceof Error) {
+      throw new Error(
+        `Failed to read collection ${collectionName}: ${error.message}`
+      );
     }
+    throw new Error(
+      `Failed to read collection ${collectionName}: Unknown error`
+    );
   }
-  return Object.keys(validSort).length > 0 ? validSort : null;
 }
-function parseFilter(filter, objectIdMode = "auto") {
-  if (!filter) {
-    return {};
+async function buildCollectionSchema(db, collection, signal, sendProgress) {
+  const collectionName = collection.collectionName;
+  const sampleSize = 100;
+  let sampleDocuments = [];
+  await sendProgress?.(1, 4, "Sampling documents");
+  try {
+    sampleDocuments = await collection.aggregate([{ $sample: { size: sampleSize } }], { signal }).toArray();
+  } catch (sampleError) {
+    signal?.throwIfAborted();
+    console.warn(
+      `$sample aggregation failed for ${collectionName}, falling back to sequential scan: ${sampleError}`
+    );
+    signal?.throwIfAborted();
+    sampleDocuments = await collection.find({}, { signal }).limit(sampleSize).toArray();
   }
-  if (typeof filter === "string") {
+  await sendProgress?.(2, 4, "Getting indexes");
+  signal?.throwIfAborted();
+  const indexOptions = {
+    signal
+  };
+  const indexes = await collection.indexes(indexOptions);
+  const inferredSchema = inferSchemaFromSamples(sampleDocuments);
+  await sendProgress?.(3, 4, "Counting documents");
+  let documentCount = null;
+  try {
+    signal?.throwIfAborted();
+    documentCount = await collection.countDocuments(
+      {},
+      { timeoutMS: 5e3, signal }
+    );
+  } catch (countError) {
+    signal?.throwIfAborted();
+    console.warn(
+      `Count operation failed or timed out for ${collectionName}: ${countError}`
+    );
     try {
-      return processObjectIdInFilter(JSON.parse(filter), objectIdMode);
+      signal?.throwIfAborted();
+      const stats = await db.command(
+        { collStats: collectionName },
+        { timeoutMS: 5e3, signal }
+      );
+      documentCount = stats.count;
     } catch {
-      throw new Error("Invalid filter format: must be a valid JSON object");
+      signal?.throwIfAborted();
+      documentCount = "unknown (count operation timed out)";
     }
   }
-  if (typeof filter === "object" && filter !== null && !Array.isArray(filter)) {
-    return processObjectIdInFilter(
-      filter,
-      objectIdMode
-    );
-  }
-  throw new Error("Query filter must be a plain object or ObjectId");
-}
-function isObjectIdField(fieldName) {
-  const lowerFieldName = fieldName.toLowerCase();
-  return lowerFieldName === "_id" || lowerFieldName === "id" || lowerFieldName.endsWith("id") || lowerFieldName.endsWith("_id");
+  await sendProgress?.(4, 4, "Done");
+  return {
+    type: "collection",
+    name: collectionName,
+    fields: inferredSchema.fields,
+    indexes: indexes.map((idx) => ({
+      name: idx.name,
+      keys: idx.key
+    })),
+    documentCount,
+    sampleSize: sampleDocuments.length,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
-function processObjectIdInFilter(filter, objectIdMode = "auto", depth = 0) {
-  if (depth > MAX_OBJECT_DEPTH) {
-    throw new Error(
-      `Object nesting exceeds the maximum depth of ${MAX_OBJECT_DEPTH}`
-    );
-  }
-  if (objectIdMode === "none") {
-    const result2 = {};
-    for (const [key, value] of Object.entries(filter)) {
-      if (typeof value === "string" && isISODateString(value)) {
-        result2[key] = new Date(value);
-      } else if (typeof value === "string" && value.startsWith("ISODate(") && value.endsWith(")")) {
-        const dateString = value.substring(8, value.length - 2);
-        if (isISODateString(dateString)) {
-          result2[key] = new Date(dateString);
-        } else {
-          result2[key] = value;
-        }
-      } else if (typeof value === "object" && value !== null) {
-        if (Array.isArray(value)) {
-          result2[key] = value.map((item) => {
-            if (typeof item === "string" && isISODateString(item)) {
-              return new Date(item);
-            } else if (typeof item === "string" && item.startsWith("ISODate(") && item.endsWith(")")) {
-              const dateString = item.substring(8, item.length - 2);
-              return isISODateString(dateString) ? new Date(dateString) : item;
-            }
-            return item;
-          });
-        } else {
-          result2[key] = processObjectIdInFilter(
-            value,
-            "none",
-            depth + 1
-          );
-        }
-      } else {
-        result2[key] = value;
-      }
+async function handleListResourcesRequest({
+  request,
+  client,
+  db,
+  isReadOnlyMode,
+  signal
+}) {
+  try {
+    signal?.throwIfAborted();
+    const collections = await db.listCollections().toArray();
+    const allResources = collections.map((collection) => ({
+      uri: `mongodb:///${encodeURIComponent(collection.name)}`,
+      mimeType: "application/json",
+      name: collection.name,
+      description: `MongoDB collection: ${collection.name}`
+    }));
+    const cursor = request.params?.cursor;
+    const { items, nextCursor } = paginate(allResources, cursor);
+    return {
+      resources: items,
+      ...nextCursor ? { nextCursor } : {}
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to list collections: ${error.message}`);
     }
-    return result2;
+    throw new Error("Failed to list collections: Unknown error");
   }
-  const result = {};
-  for (const [key, value] of Object.entries(filter)) {
-    if (typeof value === "string" && isObjectIdString(value)) {
-      if (objectIdMode === "force" || objectIdMode === "auto" && isObjectIdField(key)) {
-        result[key] = new ObjectId(value);
-      } else {
-        result[key] = value;
-      }
-    } else if (typeof value === "string" && isISODateString(value)) {
-      result[key] = new Date(value);
-    } else if (typeof value === "string" && value.startsWith("ISODate(") && value.endsWith(")")) {
-      const dateString = value.substring(8, value.length - 2);
-      if (isISODateString(dateString)) {
+}
+
+// src/schemas/tools.ts
+var WRITE_OPERATIONS = /* @__PURE__ */ new Set(["update", "insert", "createIndex"]);
+async function handleListToolsRequest({
+  request,
+  client,
+  db,
+  isReadOnlyMode,
+  signal,
+  connectionSelection = false,
+  hasWritableConnection = !isReadOnlyMode,
+  queryLimits = {}
+}) {
+  const result = {
+    tools: [
+      {
+        name: "query",
+        description: "Find documents in one collection using a filter, projection, or sort. Use aggregate for grouping or joins. Request an execution plan to inspect the query.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            collection: {
+              type: "string",
+              description: "Name of the collection to query"
+            },
+            filter: {
+              type: "object",
+              description: "MongoDB query filter. Supports date strings in ISO format ('2025-01-01T00:00:00Z') and ISODate('2025-01-01T00:00:00Z') notation"
+            },
+            projection: {
+              type: "object",
+              description: "Fields to include/exclude"
+            },
+            limit: {
+              type: "number",
+              description: "Requested page size. Configured server caps may reduce the number returned.",
+              default: 10
+            },
+            includeTotal: {
+              type: "boolean",
+              description: "Include the exact match count. Set false to skip counting.",
+              default: true
+            },
+            skip: {
+              type: "number",
+              description: "Number of documents to skip before returning results",
+              default: 0
+            },
+            sort: {
+              type: "object",
+              description: "Sort order as a field-to-direction map, e.g. { orderDate: -1 } for descending or { name: 1 } for ascending"
+            },
+            explain: {
+              type: "string",
+              description: "Optional: Get query execution information",
+              enum: ["queryPlanner", "executionStats", "allPlansExecution"]
+            },
+            objectIdMode: {
+              type: "string",
+              description: "Control how 24-character hex strings are handled",
+              enum: ["auto", "none", "force"],
+              default: "auto"
+            }
+          },
+          required: ["collection"]
+        }
+      },
+      {
+        name: "aggregate",
+        description: "Run a MongoDB aggregation pipeline for grouping, joins, or multi-stage transformations. Request an execution plan to inspect the pipeline.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            collection: {
+              type: "string",
+              description: "Name of the collection to aggregate"
+            },
+            pipeline: {
+              type: "array",
+              description: "Aggregation pipeline stages. Supports date strings in ISO format ('2025-01-01T00:00:00Z') and ISODate('2025-01-01T00:00:00Z') notation",
+              items: {
+                type: "object"
+              }
+            },
+            explain: {
+              type: "string",
+              description: "Optional: Get aggregation execution information (queryPlanner, executionStats, or allPlansExecution)",
+              enum: ["queryPlanner", "executionStats", "allPlansExecution"]
+            },
+            objectIdMode: {
+              type: "string",
+              description: "Control how 24-character hex strings are handled",
+              enum: ["auto", "none", "force"],
+              default: "auto"
+            }
+          },
+          required: ["collection", "pipeline"]
+        }
+      },
+      {
+        name: "update",
+        description: "Modify matching documents using operators such as $set, $unset, or $inc. Enable multi to update all matches or upsert to create a document when the filter matches none.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            collection: {
+              type: "string",
+              description: "Name of the collection to update"
+            },
+            filter: {
+              type: "object",
+              description: "Filter to select documents to update. Supports date strings in ISO format ('2025-01-01T00:00:00Z') and ISODate('2025-01-01T00:00:00Z') notation"
+            },
+            update: {
+              type: "object",
+              description: "Update operations to apply ($set, $unset, $inc, etc.)"
+            },
+            upsert: {
+              type: "boolean",
+              description: "Create a new document if no documents match the filter"
+            },
+            multi: {
+              type: "boolean",
+              description: "Update multiple documents that match the filter"
+            },
+            objectIdMode: {
+              type: "string",
+              description: "Control how 24-character hex strings are handled",
+              enum: ["auto", "none", "force"],
+              default: "auto"
+            }
+          },
+          required: ["collection", "filter", "update"]
+        }
+      },
+      {
+        name: "serverInfo",
+        description: "Inspect MongoDB server metadata such as version and storage engine. Enable includeDebugInfo for additional diagnostics.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            includeDebugInfo: {
+              type: "boolean",
+              description: "Include additional debug information about the server"
+            }
+          }
+        }
+      },
+      {
+        name: "insert",
+        description: "Insert new documents into a MongoDB collection. Use update to modify existing records.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            collection: {
+              type: "string",
+              description: "Name of the collection to insert into"
+            },
+            documents: {
+              type: "array",
+              description: "Array of documents to insert",
+              items: { type: "object" }
+            },
+            ordered: {
+              type: "boolean",
+              description: "If true, perform ordered insert. If false, insert unordered"
+            },
+            writeConcern: {
+              type: "object",
+              description: "Write concern for the insert operation"
+            },
+            bypassDocumentValidation: {
+              type: "boolean",
+              description: "Allow insert to bypass schema validation"
+            },
+            objectIdMode: {
+              type: "string",
+              description: "Control how 24-character hex strings are handled",
+              enum: ["auto", "none", "force"],
+              default: "auto"
+            }
+          },
+          required: ["collection", "documents"]
+        }
+      },
+      {
+        name: "createIndex",
+        description: "Create indexes to improve query performance, enforce uniqueness, or expire documents with a TTL index.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            collection: {
+              type: "string",
+              description: "Name of the collection to create indexes on"
+            },
+            indexes: {
+              type: "array",
+              description: "Array of index specifications",
+              items: {
+                type: "object",
+                properties: {
+                  key: {
+                    type: "object",
+                    description: "Index key pattern, e.g. { field: 1 }"
+                  },
+                  name: {
+                    type: "string",
+                    description: "Optional: Name of the index"
+                  },
+                  unique: {
+                    type: "boolean",
+                    description: "Optional: Creates a unique index"
+                  },
+                  sparse: {
+                    type: "boolean",
+                    description: "Optional: Creates a sparse index"
+                  },
+                  background: {
+                    type: "boolean",
+                    description: "Optional: Builds index in background"
+                  },
+                  expireAfterSeconds: {
+                    type: "number",
+                    description: "TTL in seconds for documents"
+                  },
+                  partialFilterExpression: {
+                    type: "object",
+                    description: "Filter expression for partial indexes"
+                  }
+                },
+                required: ["key"]
+              }
+            },
+            writeConcern: {
+              type: "object",
+              description: "Write concern for index creation"
+            },
+            commitQuorum: {
+              type: ["string", "number"],
+              description: "Replica-set commit quorum as a member count or a mode such as majority"
+            },
+            objectIdMode: {
+              type: "string",
+              description: "Control how 24-character hex strings are handled",
+              enum: ["auto", "none", "force"],
+              default: "auto"
+            }
+          },
+          required: ["collection", "indexes"]
+        }
+      },
+      {
+        name: "count",
+        description: "Count documents matching a filter in one collection. Use aggregate for counts grouped by field.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            collection: { type: "string", description: "Collection name" },
+            query: { type: "object", description: "Query filter to count" },
+            limit: { type: "integer", description: "Max documents to count" },
+            skip: {
+              type: "integer",
+              description: "Docs to skip before counting"
+            },
+            hint: { type: "object", description: "Index hint" },
+            readConcern: { type: "object", description: "Read concern option" },
+            maxTimeMS: { type: "integer", description: "Max execution time" },
+            collation: {
+              type: "object",
+              description: "Collation rules for comparison"
+            },
+            objectIdMode: {
+              type: "string",
+              description: "Control how 24-character hex strings are handled",
+              enum: ["auto", "none", "force"],
+              default: "auto"
+            }
+          },
+          required: ["collection"]
+        }
+      },
+      {
+        name: "listCollections",
+        description: "List collections in the connected database. Filter by name or other collection properties and request names only for a compact result.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            nameOnly: {
+              type: "boolean",
+              description: "If true, return only collection names"
+            },
+            filter: {
+              type: "object",
+              description: "Filter for collections"
+            },
+            skip: {
+              type: "number",
+              description: "Number of collections to skip before returning results",
+              default: 0
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of collections to return",
+              default: 20
+            },
+            objectIdMode: {
+              type: "string",
+              description: "Control how 24-character hex strings are handled",
+              enum: ["auto", "none", "force"],
+              default: "auto"
+            }
+          }
+        }
+      },
+      ...[
+        ["listIndexes", "List a collection's indexes, keys, and options."],
+        [
+          "collectionSchema",
+          "Infer a collection schema from sample documents and include its indexes."
+        ]
+      ].map(([name, description]) => ({
+        name,
+        description,
+        inputSchema: {
+          type: "object",
+          properties: {
+            collection: {
+              type: "string",
+              description: "Name of the collection to inspect"
+            }
+          },
+          required: ["collection"]
+        }
+      })),
+      {
+        name: "convertTime",
+        description: "Convert a Unix timestamp or date string to multiple formats (UTC ISO 8601, GMT, Unix seconds/milliseconds) and report the server's current time and timezone. Useful for building unambiguous date queries when the server and user are in different timezones. Omit 'input' to get the current time.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            input: {
+              type: "string",
+              description: "A Unix timestamp (seconds or milliseconds, as a number or numeric string) or a date string (ISO 8601, with or without a timezone offset). Omit to use the current server time."
+            }
+          }
+        }
+      }
+    ]
+  };
+  const configuredLimits = [
+    queryLimits.documents !== void 0 && `${queryLimits.documents} documents`,
+    queryLimits.bytes !== void 0 && `${queryLimits.bytes} bytes in the results array`,
+    queryLimits.timeoutMS !== void 0 && `${queryLimits.timeoutMS} ms per MongoDB operation`
+  ].filter(Boolean);
+  result.tools = result.tools.filter(
+    ({ name }) => hasWritableConnection || !WRITE_OPERATIONS.has(name)
+  );
+  const { tools } = result;
+  for (const tool of tools) {
+    if (WRITE_OPERATIONS.has(tool.name)) {
+      tool.annotations = { ...tool.annotations, readOnlyHint: false };
+      if (connectionSelection) {
+        tool.description += " Select a writable connection with listConnections.";
+      }
+    }
+    if (tool.name === "aggregate" && !hasWritableConnection) {
+      tool.annotations = { ...tool.annotations, readOnlyHint: true };
+    }
+    if ((tool.name === "query" || tool.name === "aggregate") && configuredLimits.length) {
+      tool.description += ` Configured limits include ${configuredLimits.join(", ")}.`;
+    }
+  }
+  if (connectionSelection) {
+    const connectionId = {
+      type: "string",
+      description: "Configured connection ID. Defaults to default."
+    };
+    const database = {
+      type: "string",
+      description: "Allowed database name. Defaults to the database in the connection URI."
+    };
+    for (const tool of tools) {
+      if (tool.name !== "convertTime") {
+        tool.inputSchema.properties = {
+          ...tool.inputSchema.properties,
+          connectionId,
+          database
+        };
+      }
+    }
+    tools.push(
+      {
+        name: "listConnections",
+        description: "List configured connection IDs, default databases, and read-only policies.",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "listDatabases",
+        description: "List existing authorized databases on a configured connection.",
+        inputSchema: { type: "object", properties: { connectionId } }
+      }
+    );
+  }
+  return result;
+}
+
+// src/schemas/call.ts
+var COLLECTION_OPERATIONS = [
+  "query",
+  "aggregate",
+  "update",
+  "insert",
+  "createIndex",
+  "count",
+  "listIndexes",
+  "collectionSchema"
+];
+var MAX_OBJECT_DEPTH = 100;
+var WRITE_AGG_STAGES = /* @__PURE__ */ new Set(["$out", "$merge"]);
+var SERVER_JS_AGG_OPERATORS = /* @__PURE__ */ new Set([
+  "$function",
+  "$accumulator",
+  "$where"
+]);
+var READONLY_FORBIDDEN_AGG_OPERATORS = /* @__PURE__ */ new Set([
+  ...WRITE_AGG_STAGES,
+  ...SERVER_JS_AGG_OPERATORS
+]);
+function findAggOperator(value, operators, depth = 0) {
+  if (depth > MAX_OBJECT_DEPTH) {
+    throw new Error(
+      `Object nesting exceeds the maximum depth of ${MAX_OBJECT_DEPTH}`
+    );
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findAggOperator(item, operators, depth + 1);
+      if (found) return found;
+    }
+    return null;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, nested] of Object.entries(value)) {
+      if (operators.has(key)) {
+        return key;
+      }
+      const found = findAggOperator(nested, operators, depth + 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function assertNoServerJs(value) {
+  const operator = findAggOperator(value, SERVER_JS_AGG_OPERATORS);
+  if (operator) {
+    throw new Error(
+      `Server-side JavaScript operator '${operator}' is disabled by the current server policy.`
+    );
+  }
+}
+function findCrossDbTarget(pipeline, connectedDb) {
+  const foreignDb = (target) => {
+    if (target && typeof target === "object" && "db" in target) {
+      const db = target.db;
+      if (typeof db === "string" && db && db !== connectedDb) return db;
+    }
+    return null;
+  };
+  for (const stage of pipeline) {
+    if (!stage || typeof stage !== "object") continue;
+    const s = stage;
+    const out = foreignDb(s.$out);
+    if (out) return out;
+    const merge = s.$merge;
+    const mergeInto = foreignDb(merge?.into ?? s.$merge);
+    if (mergeInto) return mergeInto;
+    const lookup = s.$lookup;
+    const lookupFrom = foreignDb(lookup?.from);
+    if (lookupFrom) return lookupFrom;
+  }
+  return null;
+}
+async function handleCallToolRequest({
+  request,
+  client,
+  db,
+  isReadOnlyMode,
+  allowCrossDb = false,
+  allowServerJs = false,
+  connections: connections2,
+  queryLimits = {},
+  signal
+}) {
+  const { name, arguments: args = {} } = request.params;
+  const operation = name;
+  const objectIdMode = args.objectIdMode || "auto";
+  const filteredArgs = {};
+  for (const [key, value] of Object.entries(args)) {
+    if (key !== "objectIdMode") {
+      filteredArgs[key] = value;
+    }
+  }
+  if (args.sort) {
+    args.sort = parseSort(args.sort);
+  }
+  Object.assign(args, filteredArgs);
+  if (!connections2 || name !== "listConnections" && name !== "listDatabases") {
+    validateOperation(operation);
+  }
+  try {
+    signal?.throwIfAborted();
+    if (connections2 && name === "listConnections") {
+      return formatResponse({ connections: connections2.list() });
+    }
+    if (connections2 && name === "listDatabases") {
+      return formatResponse({
+        databases: await connections2.listDatabases(args.connectionId)
+      });
+    }
+    if (connections2 && operation !== "convertTime") {
+      const target = await connections2.resolve(args);
+      db = target.db;
+      isReadOnlyMode = target.isReadOnlyMode;
+      if (connections2.named && operation === "aggregate" && Array.isArray(args.pipeline)) {
+        const allowed = connections2.allowedDatabases(target.connectionId);
+        checkNamedAggregationDatabases(
+          args.pipeline,
+          db.databaseName,
+          allowCrossDb ? allowed : [db.databaseName]
+        );
+      }
+    }
+    checkReadOnlyMode(operation, isReadOnlyMode);
+    let collection = null;
+    if (COLLECTION_OPERATIONS.includes(operation)) {
+      const collectionName = args.collection;
+      if (!collectionName) {
+        throw new Error(
+          `Collection name is required for '${operation}' operation`
+        );
+      }
+      collection = db.collection(collectionName);
+      validateCollection(collection);
+    }
+    signal?.throwIfAborted();
+    if (collection && (operation === "listIndexes" || operation === "collectionSchema")) {
+      const target = `${db.databaseName}.${collection.collectionName}`;
+      try {
+        const options = { signal, timeoutMS: queryLimits.timeoutMS };
+        return formatResponse(
+          operation === "listIndexes" ? { indexes: await collection.indexes(options) } : await buildCollectionSchema(db, collection, signal)
+        );
+      } catch (error) {
+        signal?.throwIfAborted();
+        return handleError(error, operation, target);
+      }
+    }
+    return await executeOperation(
+      operation,
+      collection,
+      db,
+      isReadOnlyMode,
+      allowCrossDb,
+      allowServerJs,
+      args,
+      objectIdMode,
+      queryLimits,
+      signal
+    );
+  } catch (error) {
+    if (error instanceof ProtocolError3 || signal?.aborted) {
+      throw error;
+    }
+    return toolExecutionError(
+      error instanceof Error ? error.message : "Unknown error"
+    );
+  }
+}
+function checkNamedAggregationDatabases(pipeline, database, allowed, depth = 0) {
+  if (depth > MAX_OBJECT_DEPTH)
+    throw new Error("Aggregation pipeline nesting is too deep");
+  for (const stage of pipeline) {
+    if (!stage || typeof stage !== "object") continue;
+    const { $out, $merge, $lookup, $unionWith, $facet } = stage;
+    for (const target of [$out, $merge, $lookup, $unionWith]) {
+      if (!target || typeof target !== "object") continue;
+      const value = target;
+      for (const reference of [value, value.into, value.from]) {
+        if (!reference || typeof reference !== "object" || !("db" in reference))
+          continue;
+        if (typeof reference.db !== "string" || !allowed.includes(reference.db)) {
+          throw new Error(
+            `Aggregation references a database outside the allowed scope of '${database}'`
+          );
+        }
+      }
+      if (Array.isArray(value.pipeline))
+        checkNamedAggregationDatabases(
+          value.pipeline,
+          database,
+          allowed,
+          depth + 1
+        );
+    }
+    if ($facet && typeof $facet === "object") {
+      for (const nested of Object.values($facet)) {
+        if (Array.isArray(nested))
+          checkNamedAggregationDatabases(nested, database, allowed, depth + 1);
+      }
+    }
+  }
+}
+async function executeOperation(operation, collection, db, isReadOnlyMode, allowCrossDb, allowServerJs, args, objectIdMode, queryLimits, signal) {
+  switch (operation) {
+    case "query":
+      return handleQuery(
+        collection,
+        args,
+        objectIdMode,
+        allowServerJs && !isReadOnlyMode,
+        queryLimits,
+        signal
+      );
+    case "aggregate":
+      return handleAggregate(
+        collection,
+        args,
+        objectIdMode,
+        isReadOnlyMode,
+        allowCrossDb,
+        allowServerJs,
+        queryLimits,
+        signal
+      );
+    case "update":
+      return handleUpdate(
+        collection,
+        args,
+        objectIdMode,
+        allowServerJs,
+        signal
+      );
+    case "serverInfo":
+      return handleServerInfo(db, isReadOnlyMode, args, signal);
+    case "insert":
+      return handleInsert(collection, args, objectIdMode, signal);
+    case "createIndex":
+      return handleCreateIndex(collection, args, objectIdMode, signal);
+    case "count":
+      return handleCount(
+        collection,
+        args,
+        objectIdMode,
+        allowServerJs && !isReadOnlyMode,
+        signal
+      );
+    case "listCollections":
+      return handleListCollections(db, args, objectIdMode, signal);
+    case "convertTime":
+      return handleConvertTime(args);
+    default:
+      throw new ProtocolError3(
+        ProtocolErrorCode3.InvalidParams,
+        `Unknown tool: ${operation}`
+      );
+  }
+}
+function validateOperation(operation) {
+  const validOperations = [
+    "query",
+    "aggregate",
+    "update",
+    "serverInfo",
+    "insert",
+    "createIndex",
+    "count",
+    "listCollections",
+    "listIndexes",
+    "collectionSchema",
+    "convertTime"
+  ];
+  if (!validOperations.includes(operation)) {
+    throw new ProtocolError3(
+      ProtocolErrorCode3.InvalidParams,
+      `Unknown tool: ${operation}`
+    );
+  }
+}
+function validateCollection(collection) {
+  if (!collection.collectionName) {
+    throw new Error("Collection name cannot be empty");
+  }
+  if (collection.collectionName.toLowerCase().startsWith("system.")) {
+    throw new Error("Access to system collections is not allowed");
+  }
+}
+function checkReadOnlyMode(operation, isReadOnlyMode) {
+  if (isReadOnlyMode && WRITE_OPERATIONS.has(operation)) {
+    throw new Error(
+      `ReadonlyError: Operation '${operation}' is not allowed in read-only mode`
+    );
+  }
+}
+function parseSort(sort) {
+  if (!sort) return null;
+  if (typeof sort !== "object" || sort === null || Array.isArray(sort)) {
+    return null;
+  }
+  const validSort = {};
+  for (const [key, value] of Object.entries(sort)) {
+    if (typeof value === "number" && (value === 1 || value === -1)) {
+      validSort[key] = value;
+    }
+  }
+  return Object.keys(validSort).length > 0 ? validSort : null;
+}
+function parseFilter(filter, objectIdMode = "auto") {
+  if (!filter) {
+    return {};
+  }
+  if (typeof filter === "string") {
+    try {
+      return processObjectIdInFilter(JSON.parse(filter), objectIdMode);
+    } catch {
+      throw new Error("Invalid filter format: must be a valid JSON object");
+    }
+  }
+  if (typeof filter === "object" && filter !== null && !Array.isArray(filter)) {
+    return processObjectIdInFilter(
+      filter,
+      objectIdMode
+    );
+  }
+  throw new Error("Query filter must be a plain object or ObjectId");
+}
+function isObjectIdField(fieldName) {
+  const lowerFieldName = fieldName.toLowerCase();
+  return lowerFieldName === "_id" || lowerFieldName === "id" || lowerFieldName.endsWith("id") || lowerFieldName.endsWith("_id");
+}
+function processObjectIdInFilter(filter, objectIdMode = "auto", depth = 0) {
+  if (depth > MAX_OBJECT_DEPTH) {
+    throw new Error(
+      `Object nesting exceeds the maximum depth of ${MAX_OBJECT_DEPTH}`
+    );
+  }
+  if (objectIdMode === "none") {
+    const result2 = {};
+    for (const [key, value] of Object.entries(filter)) {
+      if (typeof value === "string" && isISODateString(value)) {
+        result2[key] = new Date(value);
+      } else if (typeof value === "string" && value.startsWith("ISODate(") && value.endsWith(")")) {
+        const dateString = value.substring(8, value.length - 2);
+        if (isISODateString(dateString)) {
+          result2[key] = new Date(dateString);
+        } else {
+          result2[key] = value;
+        }
+      } else if (typeof value === "object" && value !== null) {
+        if (Array.isArray(value)) {
+          result2[key] = value.map((item) => {
+            if (typeof item === "string" && isISODateString(item)) {
+              return new Date(item);
+            } else if (typeof item === "string" && item.startsWith("ISODate(") && item.endsWith(")")) {
+              const dateString = item.substring(8, item.length - 2);
+              return isISODateString(dateString) ? new Date(dateString) : item;
+            }
+            return item;
+          });
+        } else {
+          result2[key] = processObjectIdInFilter(
+            value,
+            "none",
+            depth + 1
+          );
+        }
+      } else {
+        result2[key] = value;
+      }
+    }
+    return result2;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(filter)) {
+    if (typeof value === "string" && isObjectIdString(value)) {
+      if (objectIdMode === "force" || objectIdMode === "auto" && isObjectIdField(key)) {
+        result[key] = new ObjectId2(value);
+      } else {
+        result[key] = value;
+      }
+    } else if (typeof value === "string" && isISODateString(value)) {
+      result[key] = new Date(value);
+    } else if (typeof value === "string" && value.startsWith("ISODate(") && value.endsWith(")")) {
+      const dateString = value.substring(8, value.length - 2);
+      if (isISODateString(dateString)) {
         result[key] = new Date(dateString);
       } else {
         result[key] = value;
@@ -343,7 +1322,7 @@ function processObjectIdInFilter(filter, objectIdMode = "auto", depth = 0) {
       if (Array.isArray(value)) {
         result[key] = value.map((item) => {
           if (typeof item === "string" && isObjectIdString(item) && (objectIdMode === "force" || objectIdMode === "auto" && isObjectIdField(key))) {
-            return new ObjectId(item);
+            return new ObjectId2(item);
           } else if (typeof item === "string" && isISODateString(item)) {
             return new Date(item);
           } else if (typeof item === "string" && item.startsWith("ISODate(") && item.endsWith(")")) {
@@ -361,1294 +1340,760 @@ function processObjectIdInFilter(filter, objectIdMode = "auto", depth = 0) {
       }
     } else {
       result[key] = value;
-    }
-  }
-  return result;
-}
-function isObjectIdString(str) {
-  return /^[0-9a-fA-F]{24}$/.test(str);
-}
-function isISODateString(str) {
-  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})$/.test(
-    str
-  );
-}
-function formatResponse(data) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(data, null, 2)
-      }
-    ]
-  };
-}
-function toolExecutionError(message) {
-  return {
-    content: [{ type: "text", text: message }],
-    isError: true
-  };
-}
-function handleError(error, operation, collectionName) {
-  if (error instanceof Error && error.name === "AbortError") {
-    throw error;
-  }
-  const context = collectionName ? `collection ${collectionName}` : "operation";
-  const message = error instanceof Error ? error.message : "Unknown error";
-  return toolExecutionError(`Failed to ${operation} ${context}: ${message}`);
-}
-async function handleQuery(collection, args, objectIdMode = "auto", allowServerJs = false, signal) {
-  if (!collection) {
-    throw new Error("Collection is required for query operation");
-  }
-  const { filter, projection, explain, sort } = args;
-  const limit = args.limit || 10;
-  const skip = args.skip || 0;
-  const queryFilter = parseFilter(filter, objectIdMode);
-  if (!allowServerJs) {
-    assertNoServerJs(queryFilter);
-  }
-  try {
-    if (explain) {
-      signal?.throwIfAborted();
-      const explainResult = await collection.find(queryFilter, {
-        projection,
-        limit,
-        skip,
-        sort
-      }).explain(explain);
-      return formatResponse(explainResult);
-    }
-    signal?.throwIfAborted();
-    const [total, results] = await Promise.all([
-      collection.countDocuments(queryFilter),
-      collection.find(queryFilter, {
-        projection,
-        limit,
-        skip,
-        sort
-      }).toArray()
-    ]);
-    return formatResponse({
-      results,
-      metadata: {
-        total,
-        returned: results.length,
-        skip,
-        limit,
-        hasMore: skip + results.length < total
-      }
-    });
-  } catch (error) {
-    return handleError(error, "query", collection.collectionName);
-  }
-}
-async function handleAggregate(collection, args, objectIdMode = "auto", isReadOnlyMode = false, allowCrossDb = false, allowServerJs = false, signal) {
-  if (!collection) {
-    throw new Error("Collection is required for aggregate operation");
-  }
-  const { pipeline, explain } = args;
-  if (!Array.isArray(pipeline)) {
-    throw new Error("Pipeline must be an array");
-  }
-  if (isReadOnlyMode) {
-    const forbidden = findAggOperator(
-      pipeline,
-      READONLY_FORBIDDEN_AGG_OPERATORS
-    );
-    if (forbidden) {
-      throw new Error(
-        `ReadonlyError: Aggregation operator '${forbidden}' is not allowed in read-only mode`
-      );
-    }
-  }
-  if (!allowServerJs) {
-    assertNoServerJs(pipeline);
-  }
-  if (!allowCrossDb) {
-    const foreignDb = findCrossDbTarget(pipeline, collection.dbName);
-    if (foreignDb) {
-      throw new Error(
-        `Cross-database access to '${foreignDb}' is not allowed (connected database is '${collection.dbName}'). Enable it with --allow-cross-db or MCP_MONGODB_ALLOW_CROSS_DB=true.`
-      );
-    }
-  }
-  const processedPipeline = pipeline.map((stage) => {
-    if (typeof stage === "object" && stage !== null) {
-      return processObjectIdInFilter(
-        stage,
-        objectIdMode
-      );
-    }
-    return stage;
-  });
-  try {
-    if (explain) {
-      signal?.throwIfAborted();
-      const explainResult = await collection.aggregate(processedPipeline, {
-        explain: {
-          verbosity: explain
-        }
-      }).toArray();
-      return formatResponse(explainResult);
-    }
-    signal?.throwIfAborted();
-    const results = await collection.aggregate(processedPipeline).toArray();
-    return formatResponse({
-      results,
-      metadata: {
-        returned: results.length
-      }
-    });
-  } catch (error) {
-    return handleError(error, "aggregate", collection.collectionName);
-  }
-}
-async function handleUpdate(collection, args, objectIdMode = "auto", allowServerJs = false, signal) {
-  if (!collection) {
-    throw new Error("Collection is required for update operation");
-  }
-  const { filter, update, upsert, multi } = args;
-  const queryFilter = parseFilter(filter, objectIdMode);
-  if (!allowServerJs) {
-    assertNoServerJs(queryFilter);
-  }
-  let processedUpdate = update;
-  if (update && typeof update === "object" && !Array.isArray(update)) {
-    processedUpdate = processObjectIdInFilter(
-      update,
-      objectIdMode
-    );
-  }
-  if (!processedUpdate || typeof processedUpdate !== "object" || Array.isArray(processedUpdate)) {
-    throw new Error("Update must be a valid MongoDB update document");
-  }
-  const validUpdateOperators = [
-    "$set",
-    "$unset",
-    "$inc",
-    "$push",
-    "$pull",
-    "$addToSet",
-    "$pop",
-    "$rename",
-    "$mul"
-  ];
-  const hasValidOperator = Object.keys(processedUpdate).some(
-    (key) => validUpdateOperators.includes(key)
-  );
-  if (!hasValidOperator) {
-    throw new Error(
-      "Update must include at least one valid update operator ($set, $unset, etc.)"
-    );
-  }
-  try {
-    const options = {
-      upsert: !!upsert,
-      multi: !!multi
-    };
-    const updateMethod = options.multi ? "updateMany" : "updateOne";
-    signal?.throwIfAborted();
-    const result = await collection[updateMethod](
-      queryFilter,
-      processedUpdate,
-      options
-    );
-    return formatResponse({
-      matchedCount: result.matchedCount,
-      modifiedCount: result.modifiedCount,
-      upsertedCount: result.upsertedCount,
-      upsertedId: result.upsertedId
-    });
-  } catch (error) {
-    return handleError(error, "update", collection.collectionName);
-  }
-}
-async function handleServerInfo(db, isReadOnlyMode, args, signal) {
-  const { includeDebugInfo } = args;
-  try {
-    signal?.throwIfAborted();
-    const buildInfo = await db.command({ buildInfo: 1 });
-    const serverInfo = {
-      version: buildInfo.version,
-      gitVersion: buildInfo.gitVersion,
-      storageEngines: buildInfo.storageEngines,
-      maxBsonObjectSize: buildInfo.maxBsonObjectSize,
-      bits: buildInfo.bits,
-      ok: buildInfo.ok,
-      connectionInfo: {
-        readOnlyMode: isReadOnlyMode
-      }
-    };
-    if (includeDebugInfo) {
-      signal?.throwIfAborted();
-      const serverStatus = await db.command({ serverStatus: 1 });
-      serverInfo.modules = buildInfo.modules;
-      serverInfo.allocator = buildInfo.allocator;
-      serverInfo.javascriptEngine = buildInfo.javascriptEngine;
-      serverInfo.sysInfo = buildInfo.sysInfo;
-      serverInfo.debug = buildInfo.debug;
-      serverInfo.openssl = buildInfo.openssl;
-      serverInfo.buildEnvironment = buildInfo.buildEnvironment;
-      serverInfo.status = {
-        host: serverStatus.host,
-        version: serverStatus.version,
-        process: serverStatus.process,
-        pid: serverStatus.pid,
-        uptime: serverStatus.uptime,
-        uptimeMillis: serverStatus.uptimeMillis,
-        uptimeEstimate: serverStatus.uptimeEstimate,
-        localTime: serverStatus.localTime,
-        connections: serverStatus.connections,
-        network: serverStatus.network,
-        memory: serverStatus.mem,
-        storageEngine: serverStatus.storageEngine,
-        security: serverStatus.security
-      };
-    }
-    return formatResponse(serverInfo);
-  } catch (error) {
-    return handleError(error, "get server information");
+    }
   }
+  return result;
 }
-async function handleInsert(collection, args, objectIdMode = "auto", signal) {
-  if (!collection) {
-    throw new Error("Collection is required for insert operation");
-  }
-  const { documents, ordered, writeConcern, bypassDocumentValidation } = args;
-  if (!Array.isArray(documents)) {
-    throw new Error("Documents must be an array");
+function isObjectIdString(str) {
+  return /^[0-9a-fA-F]{24}$/.test(str);
+}
+function isISODateString(str) {
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})$/.test(
+    str
+  );
+}
+function formatResponse(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+function toolExecutionError(message) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true
+  };
+}
+function handleError(error, operation, collectionName) {
+  if (error instanceof Error && error.name === "AbortError") {
+    throw error;
   }
-  if (documents.length === 0) {
-    throw new Error("Documents array cannot be empty");
+  const context = collectionName ? `collection ${collectionName}` : "operation";
+  const message = error instanceof Error ? error.message : "Unknown error";
+  return toolExecutionError(`Failed to ${operation} ${context}: ${message}`);
+}
+async function handleQuery(collection, args, objectIdMode = "auto", allowServerJs = false, limits = {}, signal) {
+  if (!collection) {
+    throw new Error("Collection is required for query operation");
   }
-  if (!documents.every(
-    (doc) => doc && typeof doc === "object" && !Array.isArray(doc)
-  )) {
-    throw new Error("Each document must be a valid MongoDB document object");
+  const { filter, projection, explain, sort, includeTotal = true } = args;
+  if (typeof includeTotal !== "boolean")
+    throw new Error("includeTotal must be a boolean");
+  const limit = args.limit || 10;
+  const skip = args.skip || 0;
+  const queryFilter = parseFilter(filter, objectIdMode);
+  if (!allowServerJs) {
+    assertNoServerJs(queryFilter);
   }
-  const processedDocuments = documents.map(
-    (doc) => processObjectIdInFilter(doc, objectIdMode)
-  );
   try {
-    const options = {
-      ordered: ordered !== false,
-      // default to true if not specified
-      writeConcern,
-      bypassDocumentValidation
-    };
+    if (explain) {
+      signal?.throwIfAborted();
+      const explainResult = await collection.find(queryFilter, {
+        projection,
+        limit,
+        skip,
+        sort,
+        signal,
+        timeoutMS: limits.timeoutMS
+      }).explain(explain);
+      return formatResponse(explainResult);
+    }
     signal?.throwIfAborted();
-    const result = await collection.insertMany(
-      processedDocuments,
-      options
+    const bounded = limits.documents !== void 0 || limits.bytes !== void 0 || !includeTotal;
+    const pageSize = Math.abs(limit);
+    if (bounded && !Number.isSafeInteger(limit)) {
+      throw new Error("limit must be an integer");
+    }
+    const pageRows = Math.min(pageSize, limits.documents ?? Infinity);
+    const fetchLimit = bounded ? Math.sign(limit) * Math.min(pageRows + 1, Number.MAX_SAFE_INTEGER) : limit;
+    const cancelPeer = new AbortController();
+    const operationSignal = signal ? AbortSignal.any([signal, cancelPeer.signal]) : cancelPeer.signal;
+    const options = { signal: operationSignal, timeoutMS: limits.timeoutMS };
+    const cursor = collection.find(queryFilter, {
+      projection,
+      limit: fetchLimit,
+      skip,
+      sort,
+      ...options
+    });
+    const read = bounded ? readResultPage(cursor, limits, pageSize, operationSignal) : cursor.toArray().then((results) => ({
+      results,
+      hasMore: false,
+      truncated: void 0
+    }));
+    const count = includeTotal ? collection.countDocuments(queryFilter, options) : void 0;
+    const [total, page] = await Promise.all([count, read]).catch(
+      async (error) => {
+        cancelPeer.abort(error);
+        await Promise.allSettled([count, read]);
+        throw error;
+      }
     );
     return formatResponse({
-      acknowledged: result.acknowledged,
-      insertedCount: result.insertedCount,
-      insertedIds: result.insertedIds
+      results: page.results,
+      metadata: {
+        ...total !== void 0 ? { total } : {},
+        returned: page.results.length,
+        skip,
+        limit,
+        hasMore: total === void 0 ? page.hasMore : page.hasMore || skip + page.results.length < total,
+        ...page.truncated ? { truncated: page.truncated } : {}
+      }
     });
   } catch (error) {
-    if (error instanceof Error && error.name === "BulkWriteError") {
-      const bulkError = error;
-      return formatResponse({
-        error: "Bulk write error occurred",
-        writeErrors: bulkError.writeErrors,
-        insertedCount: bulkError.result?.nInserted || 0,
-        failedCount: bulkError.result?.nFailedInserts || 0
-      });
-    }
-    return handleError(error, "insert", collection.collectionName);
+    signal?.throwIfAborted();
+    return handleError(error, "query", collection.collectionName);
   }
 }
-async function handleCreateIndex(collection, args, objectIdMode = "auto", signal) {
+async function handleAggregate(collection, args, objectIdMode = "auto", isReadOnlyMode = false, allowCrossDb = false, allowServerJs = false, limits = {}, signal) {
   if (!collection) {
-    throw new Error("Collection is required for createIndex operation");
+    throw new Error("Collection is required for aggregate operation");
   }
-  const { indexes, commitQuorum, writeConcern } = args;
-  if (!Array.isArray(indexes) || indexes.length === 0) {
-    throw new Error("Indexes must be a non-empty array");
+  const { pipeline, explain } = args;
+  if (!Array.isArray(pipeline)) {
+    throw new Error("Pipeline must be an array");
   }
-  if (writeConcern && (typeof writeConcern !== "object" || Array.isArray(writeConcern))) {
-    throw new Error(
-      "Write concern must be a valid MongoDB write concern object"
+  if (isReadOnlyMode) {
+    const forbidden = findAggOperator(
+      pipeline,
+      READONLY_FORBIDDEN_AGG_OPERATORS
     );
-  }
-  if (commitQuorum !== void 0 && typeof commitQuorum !== "string" && typeof commitQuorum !== "number") {
-    throw new Error("Commit quorum must be a string or number");
-  }
-  const processedIndexes = indexes.map((index) => {
-    if (index && typeof index === "object") {
-      return processObjectIdInFilter(
-        index,
-        objectIdMode
+    if (forbidden) {
+      throw new Error(
+        `ReadonlyError: Aggregation operator '${forbidden}' is not allowed in read-only mode`
       );
     }
-    return index;
-  });
-  try {
-    const indexOptions = {
-      commitQuorum
-    };
-    signal?.throwIfAborted();
-    const createdIndexes = await collection.createIndexes(
-      processedIndexes,
-      indexOptions
-    );
-    return formatResponse({
-      acknowledged: true,
-      createdIndexes,
-      indexCount: createdIndexes.length
-    });
-  } catch (error) {
-    return handleError(error, "create indexes", collection.collectionName);
-  }
-}
-async function handleCount(collection, args, objectIdMode = "auto", allowServerJs = false, signal) {
-  if (!collection) {
-    throw new Error("Collection is required for count operation");
   }
-  const { query, limit, skip, hint, readConcern, maxTimeMS, collation } = args;
-  const countQuery = parseFilter(query, objectIdMode);
   if (!allowServerJs) {
-    assertNoServerJs(countQuery);
+    assertNoServerJs(pipeline);
   }
-  try {
-    const options = {
-      limit: typeof limit === "number" ? limit : void 0,
-      skip: typeof skip === "number" ? skip : void 0,
-      hint: typeof hint === "object" && hint !== null ? hint : void 0,
-      readConcern: typeof readConcern === "object" && readConcern !== null ? readConcern : void 0,
-      maxTimeMS: typeof maxTimeMS === "number" ? maxTimeMS : void 0,
-      collation: typeof collation === "object" && collation !== null ? collation : void 0
-    };
-    for (const key of Object.keys(options)) {
-      if (options[key] === void 0) {
-        delete options[key];
-      }
+  if (!allowCrossDb) {
+    const foreignDb = findCrossDbTarget(pipeline, collection.dbName);
+    if (foreignDb) {
+      throw new Error(
+        `Cross-database access to '${foreignDb}' is not allowed (connected database is '${collection.dbName}'). Enable it with --allow-cross-db or MCP_MONGODB_ALLOW_CROSS_DB=true.`
+      );
     }
-    signal?.throwIfAborted();
-    const count = await collection.countDocuments(countQuery, options);
-    return formatResponse({
-      count,
-      ok: 1
-    });
-  } catch (error) {
-    return handleError(error, "count documents", collection.collectionName);
   }
-}
-function handleConvertTime(args) {
-  const { input } = args;
-  let date;
-  if (input === void 0 || input === null || input === "") {
-    date = /* @__PURE__ */ new Date();
-  } else if (typeof input === "number") {
-    date = new Date(Math.abs(input) < 1e12 ? input * 1e3 : input);
-  } else if (typeof input === "string") {
-    const trimmed = input.trim();
-    if (/^-?\d+$/.test(trimmed)) {
-      const n = Number(trimmed);
-      date = new Date(Math.abs(n) < 1e12 ? n * 1e3 : n);
-    } else {
-      date = new Date(trimmed);
+  const processedPipeline = pipeline.map((stage) => {
+    if (typeof stage === "object" && stage !== null) {
+      return processObjectIdInFilter(
+        stage,
+        objectIdMode
+      );
     }
-  } else {
-    throw new Error(
-      "convertTime 'input' must be a Unix timestamp (number) or a date string"
-    );
-  }
-  if (Number.isNaN(date.getTime())) {
-    throw new Error(
-      `Could not interpret '${String(input)}' as a date or Unix timestamp`
-    );
-  }
-  const offsetMinutes = -date.getTimezoneOffset();
-  const sign = offsetMinutes >= 0 ? "+" : "-";
-  const absMinutes = Math.abs(offsetMinutes);
-  const offsetLabel = `${sign}${String(Math.floor(absMinutes / 60)).padStart(
-    2,
-    "0"
-  )}:${String(absMinutes % 60).padStart(2, "0")}`;
-  return formatResponse({
-    iso: date.toISOString(),
-    utc: date.toUTCString(),
-    unixSeconds: Math.floor(date.getTime() / 1e3),
-    unixMillis: date.getTime(),
-    serverLocal: date.toString(),
-    serverTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    serverUtcOffset: offsetLabel
+    return stage;
   });
-}
-async function handleListCollections(db, args, objectIdMode = "auto", signal) {
-  const { nameOnly, filter } = args;
-  const skip = args.skip || 0;
-  const limit = args.limit || 20;
   try {
-    const processedFilter = parseFilter(filter, objectIdMode);
+    if (explain) {
+      signal?.throwIfAborted();
+      const explainResult = await collection.aggregate(processedPipeline, {
+        explain: {
+          verbosity: explain
+        },
+        signal,
+        timeoutMS: limits.timeoutMS
+      }).toArray();
+      return formatResponse(explainResult);
+    }
     signal?.throwIfAborted();
-    const collections = await db.listCollections(processedFilter).toArray();
-    const allResults = nameOnly ? collections.map((collection) => collection.name) : collections;
-    const total = allResults.length;
-    const paged = allResults.slice(skip, skip + limit);
-    return formatResponse({
-      results: paged,
-      metadata: {
-        total,
-        returned: paged.length,
-        skip,
-        limit,
-        hasMore: skip + paged.length < total
+    const cursor = collection.aggregate(processedPipeline, {
+      signal,
+      timeoutMS: limits.timeoutMS
+    });
+    const { results, truncated } = limits.documents !== void 0 || limits.bytes !== void 0 ? await readResultPage(cursor, limits, Infinity, signal) : { results: await cursor.toArray(), truncated: void 0 };
+    return formatResponse({
+      results,
+      metadata: {
+        returned: results.length,
+        ...truncated ? { truncated } : {}
       }
     });
   } catch (error) {
-    return handleError(error, "list collections");
-  }
-}
-
-// src/utils/pagination.ts
-var DEFAULT_PAGE_SIZE = 20;
-function encodeCursor(offset) {
-  const data = { offset };
-  return Buffer.from(JSON.stringify(data)).toString("base64");
-}
-function decodeCursor(cursor) {
-  if (!cursor) return 0;
-  try {
-    const data = JSON.parse(
-      Buffer.from(cursor, "base64").toString("utf-8")
-    );
-    return typeof data.offset === "number" && data.offset >= 0 ? data.offset : 0;
-  } catch {
-    return 0;
+    signal?.throwIfAborted();
+    return handleError(error, "aggregate", collection.collectionName);
   }
 }
-function paginate(items, cursor, pageSize = DEFAULT_PAGE_SIZE) {
-  const offset = decodeCursor(cursor);
-  const page = items.slice(offset, offset + pageSize);
-  const nextOffset = offset + pageSize;
-  const nextCursor = nextOffset < items.length ? encodeCursor(nextOffset) : void 0;
-  return { items: page, nextCursor };
-}
-
-// src/schemas/completion.ts
-async function handleCompletionRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal
-}) {
-  const { ref, argument } = request.params;
-  if (ref.type === "ref/prompt") {
-    return handlePromptCompletion(
-      client,
-      db,
-      isReadOnlyMode,
-      ref.name,
-      argument,
-      signal
-    );
-  }
-  if (ref.type === "ref/resource") {
-    return handleResourceCompletion(
-      client,
-      db,
-      isReadOnlyMode,
-      ref.uri,
-      argument,
-      signal
-    );
+async function handleUpdate(collection, args, objectIdMode = "auto", allowServerJs = false, signal) {
+  if (!collection) {
+    throw new Error("Collection is required for update operation");
   }
-  return emptyCompletionResult();
-}
-async function handlePromptCompletion(client, db, isReadOnlyMode, promptName, argument, signal) {
-  if (!promptName) {
-    return emptyCompletionResult();
+  const { filter, update, upsert, multi } = args;
+  const queryFilter = parseFilter(filter, objectIdMode);
+  if (!allowServerJs) {
+    assertNoServerJs(queryFilter);
   }
-  if (argument.name === "collection") {
-    return await completeCollectionNames(
-      argument.value,
-      db,
-      isReadOnlyMode,
-      signal
+  let processedUpdate = update;
+  if (update && typeof update === "object" && !Array.isArray(update)) {
+    processedUpdate = processObjectIdInFilter(
+      update,
+      objectIdMode
     );
   }
-  return emptyCompletionResult();
-}
-async function handleResourceCompletion(client, db, isReadOnlyMode, promptName, argument, signal) {
-  if (!promptName) {
-    return emptyCompletionResult();
+  if (!processedUpdate || typeof processedUpdate !== "object" || Array.isArray(processedUpdate)) {
+    throw new Error("Update must be a valid MongoDB update document");
   }
-  if (argument.name === "collection") {
-    return await completeCollectionNames(
-      argument.value,
-      db,
-      isReadOnlyMode,
-      signal
+  const validUpdateOperators = [
+    "$set",
+    "$unset",
+    "$inc",
+    "$push",
+    "$pull",
+    "$addToSet",
+    "$pop",
+    "$rename",
+    "$mul"
+  ];
+  const hasValidOperator = Object.keys(processedUpdate).some(
+    (key) => validUpdateOperators.includes(key)
+  );
+  if (!hasValidOperator) {
+    throw new Error(
+      "Update must include at least one valid update operator ($set, $unset, etc.)"
     );
   }
-  return emptyCompletionResult();
-}
-async function completeCollectionNames(partialValue, db, isReadOnlyMode, signal) {
   try {
-    console.warn(
-      `Completing collection names with partial value: ${partialValue}`
-    );
+    const options = {
+      upsert: !!upsert,
+      multi: !!multi
+    };
+    const updateMethod = options.multi ? "updateMany" : "updateOne";
     signal?.throwIfAborted();
-    const collections = await db.listCollections().toArray();
-    const matchingCollections = collections.map(
-      (c) => c.name
-    ).filter(
-      (name) => (
-        // Filter out system collections
-        !name.startsWith("system.") && // Match partial value
-        name.toLowerCase().includes(partialValue.toLowerCase())
-      )
-    ).sort();
-    console.warn(`Found ${matchingCollections.length} matching collections`);
-    const PAGE_SIZE = 100;
-    const { items: limitedResults, nextCursor } = paginate(
-      matchingCollections,
-      void 0,
-      PAGE_SIZE
+    const result = await collection[updateMethod](
+      queryFilter,
+      processedUpdate,
+      options
     );
-    return {
-      completion: {
-        values: limitedResults,
-        total: matchingCollections.length,
-        hasMore: !!nextCursor
-      }
-    };
+    return formatResponse({
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount,
+      upsertedCount: result.upsertedCount,
+      upsertedId: result.upsertedId
+    });
   } catch (error) {
-    console.error("Error completing collection names:", error);
-    return emptyCompletionResult();
+    return handleError(error, "update", collection.collectionName);
   }
 }
-function emptyCompletionResult() {
-  return {
-    completion: {
-      values: [],
-      total: 0,
-      hasMore: false
-    }
-  };
-}
-
-// src/schemas/ping.ts
-async function handlePingRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal
-}) {
+async function handleServerInfo(db, isReadOnlyMode, args, signal) {
+  const { includeDebugInfo } = args;
   try {
-    if (!client) {
-      throw new Error("MongoDB connection is not available");
-    }
     signal?.throwIfAborted();
-    const pong = await db.command({ ping: 1 });
-    if (pong.ok !== 1) {
-      throw new Error(`MongoDB ping failed: ${pong.errmsg}`);
+    const buildInfo = await db.command({ buildInfo: 1 });
+    const serverInfo = {
+      version: buildInfo.version,
+      gitVersion: buildInfo.gitVersion,
+      storageEngines: buildInfo.storageEngines,
+      maxBsonObjectSize: buildInfo.maxBsonObjectSize,
+      bits: buildInfo.bits,
+      ok: buildInfo.ok,
+      connectionInfo: {
+        readOnlyMode: isReadOnlyMode
+      }
+    };
+    if (includeDebugInfo) {
+      signal?.throwIfAborted();
+      const serverStatus = await db.command({ serverStatus: 1 });
+      serverInfo.modules = buildInfo.modules;
+      serverInfo.allocator = buildInfo.allocator;
+      serverInfo.javascriptEngine = buildInfo.javascriptEngine;
+      serverInfo.sysInfo = buildInfo.sysInfo;
+      serverInfo.debug = buildInfo.debug;
+      serverInfo.openssl = buildInfo.openssl;
+      serverInfo.buildEnvironment = buildInfo.buildEnvironment;
+      serverInfo.status = {
+        host: serverStatus.host,
+        version: serverStatus.version,
+        process: serverStatus.process,
+        pid: serverStatus.pid,
+        uptime: serverStatus.uptime,
+        uptimeMillis: serverStatus.uptimeMillis,
+        uptimeEstimate: serverStatus.uptimeEstimate,
+        localTime: serverStatus.localTime,
+        connections: serverStatus.connections,
+        network: serverStatus.network,
+        memory: serverStatus.mem,
+        storageEngine: serverStatus.storageEngine,
+        security: serverStatus.security
+      };
     }
-    return {};
+    return formatResponse(serverInfo);
   } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`MongoDB ping failed: ${error.message}`);
-    }
-    throw new Error("MongoDB ping failed: Unknown error");
+    return handleError(error, "get server information");
   }
 }
-
-// src/schemas/prompts.ts
-async function handleListPromptsRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal
-}) {
-  return {
-    prompts: [
-      {
-        name: "analyze_collection",
-        description: "Analyze a MongoDB collection structure and contents",
-        arguments: [
-          {
-            name: "collection",
-            description: "Name of the collection to analyze",
-            required: true
-          }
-        ]
-      }
-    ]
-  };
-}
-async function handleGetPromptRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal,
-  sendProgress
-}) {
-  const { name, arguments: args = {} } = request.params;
-  if (name !== "analyze_collection") {
-    throw new Error("Unknown prompt");
+async function handleInsert(collection, args, objectIdMode = "auto", signal) {
+  if (!collection) {
+    throw new Error("Collection is required for insert operation");
   }
-  const collectionName = args.collection;
-  if (!collectionName) {
-    throw new Error("Collection name is required");
+  const { documents, ordered, writeConcern, bypassDocumentValidation } = args;
+  if (!Array.isArray(documents)) {
+    throw new Error("Documents must be an array");
+  }
+  if (documents.length === 0) {
+    throw new Error("Documents array cannot be empty");
+  }
+  if (!documents.every(
+    (doc) => doc && typeof doc === "object" && !Array.isArray(doc)
+  )) {
+    throw new Error("Each document must be a valid MongoDB document object");
   }
+  const processedDocuments = documents.map(
+    (doc) => processObjectIdInFilter(doc, objectIdMode)
+  );
   try {
-    const collection = db.collection(collectionName);
-    if (collection.collectionName.startsWith("system.")) {
-      throw new Error("Access to system collections is not allowed");
-    }
-    await sendProgress?.(1, 3, "Getting schema");
-    signal?.throwIfAborted();
-    const schemaSample = await collection.findOne({});
-    await sendProgress?.(2, 3, "Getting stats");
-    signal?.throwIfAborted();
-    const stats = await collection.aggregate([{ $collStats: { count: {} } }]).toArray();
-    await sendProgress?.(3, 3, "Fetching samples");
-    signal?.throwIfAborted();
-    const sampleDocs = await collection.find({}).limit(5).toArray();
-    const documentCount = stats[0]?.count ?? "unknown";
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: `Please analyze the following MongoDB collection:
-Collection: ${collectionName}
-
-Schema:
-${JSON.stringify(schemaSample, null, 2)}
-
-Stats:
-Document count: ${documentCount}
-
-Sample documents:
-${JSON.stringify(sampleDocs, null, 2)}`
-          }
-        },
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: "Provide insights about the collection's structure, data types, and basic statistics."
-          }
-        }
-      ]
+    const options = {
+      ordered: ordered !== false,
+      // default to true if not specified
+      writeConcern,
+      bypassDocumentValidation
     };
+    signal?.throwIfAborted();
+    const result = await collection.insertMany(
+      processedDocuments,
+      options
+    );
+    return formatResponse({
+      acknowledged: result.acknowledged,
+      insertedCount: result.insertedCount,
+      insertedIds: result.insertedIds
+    });
   } catch (error) {
-    const msg = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Failed to analyze collection ${collectionName}: ${msg}`);
-  }
-}
-
-// src/schemas/resource.ts
-import {
-  ProtocolError as ProtocolError2,
-  ProtocolErrorCode as ProtocolErrorCode2
-} from "@modelcontextprotocol/server";
-import { ObjectId as ObjectId2 } from "mongodb";
-function detectMongoType(value) {
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  if (value instanceof ObjectId2) return "ObjectId";
-  if (value instanceof Date) return "Date";
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "Array";
-    const elementTypes = new Set(value.map((item) => detectMongoType(item)));
-    if (elementTypes.size === 1) {
-      return `Array<${Array.from(elementTypes)[0]}>`;
+    if (error instanceof Error && error.name === "BulkWriteError") {
+      const bulkError = error;
+      return formatResponse({
+        error: "Bulk write error occurred",
+        writeErrors: bulkError.writeErrors,
+        insertedCount: bulkError.result?.nInserted || 0,
+        failedCount: bulkError.result?.nFailedInserts || 0
+      });
     }
-    return "Array<mixed>";
-  }
-  if (typeof value === "object") {
-    return "Document";
+    return handleError(error, "insert", collection.collectionName);
   }
-  return typeof value;
 }
-function inferSchemaFromSamples(documents) {
-  if (!documents || documents.length === 0) {
-    return { fields: [] };
+async function handleCreateIndex(collection, args, objectIdMode = "auto", signal) {
+  if (!collection) {
+    throw new Error("Collection is required for createIndex operation");
   }
-  const fieldMap = /* @__PURE__ */ new Map();
-  for (const doc of documents) {
-    for (const [key, value] of Object.entries(doc)) {
-      if (!fieldMap.has(key)) {
-        fieldMap.set(key, {
-          name: key,
-          types: /* @__PURE__ */ new Set([detectMongoType(value)]),
-          nullable: false,
-          // Store sample values for complex types
-          samples: [value]
-        });
-      } else {
-        const fieldInfo = fieldMap.get(key);
-        fieldInfo.types.add(detectMongoType(value));
-        if (fieldInfo.samples.length < 3 && !fieldInfo.samples.some(
-          (sample) => JSON.stringify(sample) === JSON.stringify(value)
-        )) {
-          fieldInfo.samples.push(value);
-        }
-      }
-    }
+  const { indexes, commitQuorum, writeConcern } = args;
+  if (!Array.isArray(indexes) || indexes.length === 0) {
+    throw new Error("Indexes must be a non-empty array");
   }
-  for (const doc of documents) {
-    for (const [key] of fieldMap.entries()) {
-      if (!(key in doc)) {
-        const fieldInfo = fieldMap.get(key);
-        fieldInfo.nullable = true;
-      }
-    }
+  if (writeConcern && (typeof writeConcern !== "object" || Array.isArray(writeConcern))) {
+    throw new Error(
+      "Write concern must be a valid MongoDB write concern object"
+    );
   }
-  for (const [key, fieldInfo] of fieldMap.entries()) {
-    if (fieldInfo.types.has("Document")) {
-      const nestedDocs = documents.filter(
-        (doc) => doc[key] && typeof doc[key] === "object" && !Array.isArray(doc[key])
-      ).map((doc) => doc[key]);
-      if (nestedDocs.length > 0) {
-        fieldInfo.nestedSchema = inferSchemaFromSamples(nestedDocs);
-      }
-    }
+  if (commitQuorum !== void 0 && typeof commitQuorum !== "string" && typeof commitQuorum !== "number") {
+    throw new Error("Commit quorum must be a string or number");
   }
-  const fields = Array.from(fieldMap.values()).map((fieldInfo) => {
-    const result = {
-      name: fieldInfo.name,
-      types: Array.from(fieldInfo.types),
-      nullable: fieldInfo.nullable,
-      prevalence: `${Math.round(
-        documents.filter((doc) => fieldInfo.name in doc).length / documents.length * 100
-      )}%`,
-      examples: []
-    };
-    if (fieldInfo.nestedSchema) {
-      result.nestedSchema = fieldInfo.nestedSchema;
+  const processedIndexes = indexes.map((index) => {
+    if (index && typeof index === "object") {
+      return processObjectIdInFilter(
+        index,
+        objectIdMode
+      );
     }
-    const sampleValues = fieldInfo.samples.map((sample) => {
-      if (sample instanceof ObjectId2) return sample.toString();
-      if (sample instanceof Date) return sample.toISOString();
-      if (typeof sample === "object") {
-        return Array.isArray(sample) ? "[...]" : "{...}";
-      }
-      return sample;
-    });
-    result.examples = sampleValues;
-    return result;
+    return index;
   });
-  return { fields };
+  try {
+    const indexOptions = {
+      commitQuorum
+    };
+    signal?.throwIfAborted();
+    const createdIndexes = await collection.createIndexes(
+      processedIndexes,
+      indexOptions
+    );
+    return formatResponse({
+      acknowledged: true,
+      createdIndexes,
+      indexCount: createdIndexes.length
+    });
+  } catch (error) {
+    return handleError(error, "create indexes", collection.collectionName);
+  }
 }
-async function handleReadResourceRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal,
-  sendProgress
-}) {
-  let collectionName;
+async function handleCount(collection, args, objectIdMode = "auto", allowServerJs = false, signal) {
+  if (!collection) {
+    throw new Error("Collection is required for count operation");
+  }
+  const { query, limit, skip, hint, readConcern, maxTimeMS, collation } = args;
+  const countQuery = parseFilter(query, objectIdMode);
+  if (!allowServerJs) {
+    assertNoServerJs(countQuery);
+  }
   try {
-    const url = new URL(request.params.uri);
-    if (url.protocol !== "mongodb:") {
-      throw new ProtocolError2(
-        ProtocolErrorCode2.InvalidParams,
-        `Unsupported resource URI scheme '${url.protocol}': expected 'mongodb:'`
-      );
+    const options = {
+      limit: typeof limit === "number" ? limit : void 0,
+      skip: typeof skip === "number" ? skip : void 0,
+      hint: typeof hint === "object" && hint !== null ? hint : void 0,
+      readConcern: typeof readConcern === "object" && readConcern !== null ? readConcern : void 0,
+      maxTimeMS: typeof maxTimeMS === "number" ? maxTimeMS : void 0,
+      collation: typeof collation === "object" && collation !== null ? collation : void 0
+    };
+    for (const key of Object.keys(options)) {
+      if (options[key] === void 0) {
+        delete options[key];
+      }
     }
-    collectionName = decodeURIComponent(url.pathname.replace(/^\//, ""));
+    signal?.throwIfAborted();
+    const count = await collection.countDocuments(countQuery, options);
+    return formatResponse({
+      count,
+      ok: 1
+    });
   } catch (error) {
-    if (error instanceof ProtocolError2) throw error;
-    throw new ProtocolError2(
-      ProtocolErrorCode2.InvalidParams,
-      `Invalid resource URI: ${request.params.uri}`
-    );
+    return handleError(error, "count documents", collection.collectionName);
   }
-  if (!collectionName) {
-    throw new ProtocolError2(
-      ProtocolErrorCode2.InvalidParams,
-      "Resource URI is missing a collection name"
+}
+function handleConvertTime(args) {
+  const { input } = args;
+  let date;
+  if (input === void 0 || input === null || input === "") {
+    date = /* @__PURE__ */ new Date();
+  } else if (typeof input === "number") {
+    date = new Date(Math.abs(input) < 1e12 ? input * 1e3 : input);
+  } else if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (/^-?\d+$/.test(trimmed)) {
+      const n = Number(trimmed);
+      date = new Date(Math.abs(n) < 1e12 ? n * 1e3 : n);
+    } else {
+      date = new Date(trimmed);
+    }
+  } else {
+    throw new Error(
+      "convertTime 'input' must be a Unix timestamp (number) or a date string"
     );
   }
-  if (collectionName.startsWith("system.")) {
-    throw new ProtocolError2(
-      ProtocolErrorCode2.InvalidParams,
-      "Access to system collections is not allowed"
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(
+      `Could not interpret '${String(input)}' as a date or Unix timestamp`
     );
   }
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absMinutes = Math.abs(offsetMinutes);
+  const offsetLabel = `${sign}${String(Math.floor(absMinutes / 60)).padStart(
+    2,
+    "0"
+  )}:${String(absMinutes % 60).padStart(2, "0")}`;
+  return formatResponse({
+    iso: date.toISOString(),
+    utc: date.toUTCString(),
+    unixSeconds: Math.floor(date.getTime() / 1e3),
+    unixMillis: date.getTime(),
+    serverLocal: date.toString(),
+    serverTimeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    serverUtcOffset: offsetLabel
+  });
+}
+async function handleListCollections(db, args, objectIdMode = "auto", signal) {
+  const { nameOnly, filter } = args;
+  const skip = args.skip || 0;
+  const limit = args.limit || 20;
   try {
-    const collection = db.collection(collectionName);
-    const sampleSize = 100;
-    let sampleDocuments = [];
-    await sendProgress?.(1, 4, "Sampling documents");
-    try {
-      signal?.throwIfAborted();
-      sampleDocuments = await collection.aggregate([{ $sample: { size: sampleSize } }]).toArray();
-    } catch (sampleError) {
-      console.warn(
-        `$sample aggregation failed for ${collectionName}, falling back to sequential scan: ${sampleError}`
-      );
-      signal?.throwIfAborted();
-      sampleDocuments = await collection.find({}).limit(sampleSize).toArray();
-    }
-    await sendProgress?.(2, 4, "Getting indexes");
+    const processedFilter = parseFilter(filter, objectIdMode);
     signal?.throwIfAborted();
-    const indexes = await collection.indexes();
-    const inferredSchema = inferSchemaFromSamples(sampleDocuments);
-    await sendProgress?.(3, 4, "Counting documents");
-    let documentCount = null;
-    try {
-      signal?.throwIfAborted();
-      documentCount = await Promise.race([
-        collection.countDocuments(),
-        new Promise(
-          (_, reject) => setTimeout(
-            () => reject(new Error("Count operation timed out")),
-            5e3
-          )
-        )
-      ]);
-    } catch (countError) {
-      console.warn(
-        `Count operation failed or timed out for ${collectionName}: ${countError}`
-      );
-      try {
-        signal?.throwIfAborted();
-        const stats = await db.command({ collStats: collectionName });
-        documentCount = stats.count;
-      } catch {
-        documentCount = "unknown (count operation timed out)";
+    const collections = await db.listCollections(processedFilter).toArray();
+    const allResults = nameOnly ? collections.map((collection) => collection.name) : collections;
+    const total = allResults.length;
+    const paged = allResults.slice(skip, skip + limit);
+    return formatResponse({
+      results: paged,
+      metadata: {
+        total,
+        returned: paged.length,
+        skip,
+        limit,
+        hasMore: skip + paged.length < total
       }
-    }
-    await sendProgress?.(4, 4, "Done");
-    const schema = {
-      type: "collection",
-      name: collectionName,
-      fields: inferredSchema.fields,
-      indexes: indexes.map((idx) => ({
-        name: idx.name,
-        keys: idx.key
-      })),
-      documentCount,
-      sampleSize: sampleDocuments.length,
-      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    return {
-      contents: [
-        {
-          uri: request.params.uri,
-          mimeType: "application/json",
-          text: JSON.stringify(schema, null, 2)
-        }
-      ]
-    };
+    });
   } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(
-        `Failed to read collection ${collectionName}: ${error.message}`
-      );
-    }
-    throw new Error(
-      `Failed to read collection ${collectionName}: Unknown error`
-    );
+    return handleError(error, "list collections");
   }
 }
-async function handleListResourcesRequest({
+
+// src/schemas/completion.ts
+async function handleCompletionRequest({
   request,
   client,
   db,
   isReadOnlyMode,
   signal
 }) {
+  const { ref, argument } = request.params;
+  if (ref.type === "ref/prompt") {
+    return handlePromptCompletion(
+      client,
+      db,
+      isReadOnlyMode,
+      ref.name,
+      argument,
+      signal
+    );
+  }
+  if (ref.type === "ref/resource") {
+    return handleResourceCompletion(
+      client,
+      db,
+      isReadOnlyMode,
+      ref.uri,
+      argument,
+      signal
+    );
+  }
+  return emptyCompletionResult();
+}
+async function handlePromptCompletion(client, db, isReadOnlyMode, promptName, argument, signal) {
+  if (!promptName) {
+    return emptyCompletionResult();
+  }
+  if (argument.name === "collection") {
+    return await completeCollectionNames(
+      argument.value,
+      db,
+      isReadOnlyMode,
+      signal
+    );
+  }
+  return emptyCompletionResult();
+}
+async function handleResourceCompletion(client, db, isReadOnlyMode, promptName, argument, signal) {
+  if (!promptName) {
+    return emptyCompletionResult();
+  }
+  if (argument.name === "collection") {
+    return await completeCollectionNames(
+      argument.value,
+      db,
+      isReadOnlyMode,
+      signal
+    );
+  }
+  return emptyCompletionResult();
+}
+async function completeCollectionNames(partialValue, db, isReadOnlyMode, signal) {
   try {
+    console.warn(
+      `Completing collection names with partial value: ${partialValue}`
+    );
     signal?.throwIfAborted();
     const collections = await db.listCollections().toArray();
-    const allResources = collections.map((collection) => ({
-      uri: `mongodb:///${encodeURIComponent(collection.name)}`,
-      mimeType: "application/json",
-      name: collection.name,
-      description: `MongoDB collection: ${collection.name}`
-    }));
-    const cursor = request.params?.cursor;
-    const { items, nextCursor } = paginate(allResources, cursor);
+    const matchingCollections = collections.map(
+      (c) => c.name
+    ).filter(
+      (name) => (
+        // Filter out system collections
+        !name.startsWith("system.") && // Match partial value
+        name.toLowerCase().includes(partialValue.toLowerCase())
+      )
+    ).sort();
+    console.warn(`Found ${matchingCollections.length} matching collections`);
+    const PAGE_SIZE = 100;
+    const { items: limitedResults, nextCursor } = paginate(
+      matchingCollections,
+      void 0,
+      PAGE_SIZE
+    );
     return {
-      resources: items,
-      ...nextCursor ? { nextCursor } : {}
+      completion: {
+        values: limitedResults,
+        total: matchingCollections.length,
+        hasMore: !!nextCursor
+      }
     };
   } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`Failed to list collections: ${error.message}`);
-    }
-    throw new Error("Failed to list collections: Unknown error");
+    console.error("Error completing collection names:", error);
+    return emptyCompletionResult();
   }
 }
+function emptyCompletionResult() {
+  return {
+    completion: {
+      values: [],
+      total: 0,
+      hasMore: false
+    }
+  };
+}
 
-// src/schemas/templates.ts
-async function handleListResourceTemplatesRequest({
+// src/schemas/ping.ts
+async function handlePingRequest({
   request,
   client,
   db,
   isReadOnlyMode,
-  signal
-}) {
-  return {
-    resourceTemplates: [
-      {
-        name: "mongodb_query",
-        description: "Template for constructing MongoDB queries",
-        uriTemplate: "mongodb:///{collection}",
-        text: `To query MongoDB collections, you can use these operators:
-
-Filter operators:
-- $eq: Matches values equal to a specified value
-- $gt/$gte: Matches values greater than (or equal to) a specified value
-- $lt/$lte: Matches values less than (or equal to) a specified value
-- $in: Matches any of the values in an array
-- $nin: Matches none of the values in an array
-- $ne: Matches values not equal to a specified value
-- $exists: Matches documents that have the specified field
-
-Example queries:
-1. Find documents where age > 21:
-{ "age": { "$gt": 21 } }
-
-2. Find documents with specific status:
-{ "status": { "$in": ["active", "pending"] } }
-
-3. Find documents with existing email:
-{ "email": { "$exists": true } }
-
-4. Find documents with dates:
-// Using ISO date string format
-{ "createdAt": { "$gt": "2023-01-01T00:00:00Z" } }
-// Using ISODate syntax
-{ "createdAt": { "$gt": ISODate("2023-01-01T00:00:00Z") } }
-
-Use these patterns to construct MongoDB queries.`
-      }
-    ]
-  };
+  signal
+}) {
+  try {
+    if (!client) {
+      throw new Error("MongoDB connection is not available");
+    }
+    signal?.throwIfAborted();
+    const pong = await db.command({ ping: 1 });
+    if (pong.ok !== 1) {
+      throw new Error(`MongoDB ping failed: ${pong.errmsg}`);
+    }
+    return {};
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`MongoDB ping failed: ${error.message}`);
+    }
+    throw new Error("MongoDB ping failed: Unknown error");
+  }
 }
 
-// src/schemas/tools.ts
-async function handleListToolsRequest({
+// src/schemas/prompts.ts
+async function handleListPromptsRequest({
   request,
   client,
   db,
   isReadOnlyMode,
-  signal
+  signal,
+  connectionSelection = false
 }) {
-  return {
-    tools: [
-      {
-        name: "query",
-        description: "Find documents in one collection using a filter, projection, or sort. Use aggregate for grouping or joins. Request an execution plan to inspect the query.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection to query"
-            },
-            filter: {
-              type: "object",
-              description: "MongoDB query filter. Supports date strings in ISO format ('2025-01-01T00:00:00Z') and ISODate('2025-01-01T00:00:00Z') notation"
-            },
-            projection: {
-              type: "object",
-              description: "Fields to include/exclude"
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of documents to return",
-              default: 10
-            },
-            skip: {
-              type: "number",
-              description: "Number of documents to skip before returning results",
-              default: 0
-            },
-            sort: {
-              type: "object",
-              description: "Sort order as a field-to-direction map, e.g. { orderDate: -1 } for descending or { name: 1 } for ascending"
-            },
-            explain: {
-              type: "string",
-              description: "Optional: Get query execution information",
-              enum: ["queryPlanner", "executionStats", "allPlansExecution"]
-            },
-            objectIdMode: {
-              type: "string",
-              description: "Control how 24-character hex strings are handled",
-              enum: ["auto", "none", "force"],
-              default: "auto"
-            }
-          },
-          required: ["collection"]
-        }
-      },
-      {
-        name: "aggregate",
-        description: "Run a MongoDB aggregation pipeline for grouping, joins, or multi-stage transformations. Request an execution plan to inspect the pipeline.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection to aggregate"
-            },
-            pipeline: {
-              type: "array",
-              description: "Aggregation pipeline stages. Supports date strings in ISO format ('2025-01-01T00:00:00Z') and ISODate('2025-01-01T00:00:00Z') notation",
-              items: {
-                type: "object"
-              }
-            },
-            explain: {
-              type: "string",
-              description: "Optional: Get aggregation execution information (queryPlanner, executionStats, or allPlansExecution)",
-              enum: ["queryPlanner", "executionStats", "allPlansExecution"]
-            },
-            objectIdMode: {
-              type: "string",
-              description: "Control how 24-character hex strings are handled",
-              enum: ["auto", "none", "force"],
-              default: "auto"
-            }
-          },
-          required: ["collection", "pipeline"]
-        }
-      },
-      {
-        name: "update",
-        description: "Modify matching documents using operators such as $set, $unset, or $inc. Enable multi to update all matches or upsert to create a document when the filter matches none.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection to update"
-            },
-            filter: {
-              type: "object",
-              description: "Filter to select documents to update. Supports date strings in ISO format ('2025-01-01T00:00:00Z') and ISODate('2025-01-01T00:00:00Z') notation"
-            },
-            update: {
-              type: "object",
-              description: "Update operations to apply ($set, $unset, $inc, etc.)"
-            },
-            upsert: {
-              type: "boolean",
-              description: "Create a new document if no documents match the filter"
-            },
-            multi: {
-              type: "boolean",
-              description: "Update multiple documents that match the filter"
-            },
-            objectIdMode: {
-              type: "string",
-              description: "Control how 24-character hex strings are handled",
-              enum: ["auto", "none", "force"],
-              default: "auto"
-            }
-          },
-          required: ["collection", "filter", "update"]
-        }
-      },
-      {
-        name: "serverInfo",
-        description: "Inspect MongoDB server metadata such as version and storage engine. Enable includeDebugInfo for additional diagnostics.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            includeDebugInfo: {
-              type: "boolean",
-              description: "Include additional debug information about the server"
-            }
-          }
-        }
-      },
-      {
-        name: "insert",
-        description: "Insert new documents into a MongoDB collection. Use update to modify existing records.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection to insert into"
-            },
-            documents: {
-              type: "array",
-              description: "Array of documents to insert",
-              items: { type: "object" }
-            },
-            ordered: {
-              type: "boolean",
-              description: "If true, perform ordered insert. If false, insert unordered"
-            },
-            writeConcern: {
-              type: "object",
-              description: "Write concern for the insert operation"
-            },
-            bypassDocumentValidation: {
-              type: "boolean",
-              description: "Allow insert to bypass schema validation"
-            },
-            objectIdMode: {
-              type: "string",
-              description: "Control how 24-character hex strings are handled",
-              enum: ["auto", "none", "force"],
-              default: "auto"
-            }
-          },
-          required: ["collection", "documents"]
-        }
-      },
-      {
-        name: "createIndex",
-        description: "Create indexes to improve query performance, enforce uniqueness, or expire documents with a TTL index.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: {
-              type: "string",
-              description: "Name of the collection to create indexes on"
-            },
-            indexes: {
-              type: "array",
-              description: "Array of index specifications",
-              items: {
-                type: "object",
-                properties: {
-                  key: {
-                    type: "object",
-                    description: "Index key pattern, e.g. { field: 1 }"
-                  },
-                  name: {
-                    type: "string",
-                    description: "Optional: Name of the index"
-                  },
-                  unique: {
-                    type: "boolean",
-                    description: "Optional: Creates a unique index"
-                  },
-                  sparse: {
-                    type: "boolean",
-                    description: "Optional: Creates a sparse index"
-                  },
-                  background: {
-                    type: "boolean",
-                    description: "Optional: Builds index in background"
-                  },
-                  expireAfterSeconds: {
-                    type: "number",
-                    description: "TTL in seconds for documents"
-                  },
-                  partialFilterExpression: {
-                    type: "object",
-                    description: "Filter expression for partial indexes"
-                  }
-                },
-                required: ["key"]
-              }
-            },
-            writeConcern: {
-              type: "object",
-              description: "Write concern for index creation"
-            },
-            commitQuorum: {
-              type: ["string", "number"],
-              description: "Replica-set commit quorum as a member count or a mode such as majority"
-            },
-            objectIdMode: {
-              type: "string",
-              description: "Control how 24-character hex strings are handled",
-              enum: ["auto", "none", "force"],
-              default: "auto"
-            }
-          },
-          required: ["collection", "indexes"]
-        }
-      },
+  return {
+    prompts: [
       {
-        name: "count",
-        description: "Count documents matching a filter in one collection. Use aggregate for counts grouped by field.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            collection: { type: "string", description: "Collection name" },
-            query: { type: "object", description: "Query filter to count" },
-            limit: { type: "integer", description: "Max documents to count" },
-            skip: {
-              type: "integer",
-              description: "Docs to skip before counting"
-            },
-            hint: { type: "object", description: "Index hint" },
-            readConcern: { type: "object", description: "Read concern option" },
-            maxTimeMS: { type: "integer", description: "Max execution time" },
-            collation: {
-              type: "object",
-              description: "Collation rules for comparison"
-            },
-            objectIdMode: {
-              type: "string",
-              description: "Control how 24-character hex strings are handled",
-              enum: ["auto", "none", "force"],
-              default: "auto"
-            }
+        name: "analyze_collection",
+        description: "Analyze a MongoDB collection structure and contents",
+        arguments: [
+          {
+            name: "collection",
+            description: "Name of the collection to analyze",
+            required: true
           },
-          required: ["collection"]
-        }
-      },
-      {
-        name: "listCollections",
-        description: "List collections in the connected database. Filter by name or other collection properties and request names only for a compact result.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            nameOnly: {
-              type: "boolean",
-              description: "If true, return only collection names"
-            },
-            filter: {
-              type: "object",
-              description: "Filter for collections"
-            },
-            skip: {
-              type: "number",
-              description: "Number of collections to skip before returning results",
-              default: 0
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of collections to return",
-              default: 20
+          ...connectionSelection ? [
+            {
+              name: "connectionId",
+              description: "Configured MongoDB connection ID"
             },
-            objectIdMode: {
-              type: "string",
-              description: "Control how 24-character hex strings are handled",
-              enum: ["auto", "none", "force"],
-              default: "auto"
+            {
+              name: "database",
+              description: "Allowed MongoDB database name"
             }
+          ] : []
+        ]
+      }
+    ]
+  };
+}
+async function handleGetPromptRequest({
+  request,
+  client,
+  db,
+  isReadOnlyMode,
+  signal,
+  sendProgress,
+  connectionId,
+  showTarget = false
+}) {
+  const { name, arguments: args = {} } = request.params;
+  if (name !== "analyze_collection") {
+    throw new Error("Unknown prompt");
+  }
+  const collectionName = args.collection;
+  if (!collectionName) {
+    throw new Error("Collection name is required");
+  }
+  try {
+    const collection = db.collection(collectionName);
+    if (collection.collectionName.startsWith("system.")) {
+      throw new Error("Access to system collections is not allowed");
+    }
+    await sendProgress?.(1, 3, "Getting schema");
+    signal?.throwIfAborted();
+    const schemaSample = await collection.findOne({});
+    await sendProgress?.(2, 3, "Getting stats");
+    signal?.throwIfAborted();
+    const stats = await collection.aggregate([{ $collStats: { count: {} } }]).toArray();
+    await sendProgress?.(3, 3, "Fetching samples");
+    signal?.throwIfAborted();
+    const sampleDocs = await collection.find({}).limit(5).toArray();
+    const documentCount = stats[0]?.count ?? "unknown";
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Please analyze the following MongoDB collection:
+Collection: ${collectionName}${showTarget ? `
+Connection: ${connectionId}
+Database: ${db.databaseName}` : ""}
+
+Schema:
+${JSON.stringify(schemaSample, null, 2)}
+
+Stats:
+Document count: ${documentCount}
+
+Sample documents:
+${JSON.stringify(sampleDocs, null, 2)}`
           }
-        }
-      },
-      {
-        name: "convertTime",
-        description: "Convert a Unix timestamp or date string to multiple formats (UTC ISO 8601, GMT, Unix seconds/milliseconds) and report the server's current time and timezone. Useful for building unambiguous date queries when the server and user are in different timezones. Omit 'input' to get the current time.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            input: {
-              type: "string",
-              description: "A Unix timestamp (seconds or milliseconds, as a number or numeric string) or a date string (ISO 8601, with or without a timezone offset). Omit to use the current server time."
-            }
+        },
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: "Provide insights about the collection's structure, data types, and basic statistics."
           }
         }
+      ]
+    };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to analyze collection ${collectionName}: ${msg}`);
+  }
+}
+
+// src/schemas/templates.ts
+async function handleListResourceTemplatesRequest({
+  request,
+  client,
+  db,
+  isReadOnlyMode,
+  signal
+}) {
+  return {
+    resourceTemplates: [
+      {
+        name: "mongodb_query",
+        description: "Template for constructing MongoDB queries",
+        uriTemplate: "mongodb:///{collection}",
+        text: `To query MongoDB collections, you can use these operators:
+
+Filter operators:
+- $eq: Matches values equal to a specified value
+- $gt/$gte: Matches values greater than (or equal to) a specified value
+- $lt/$lte: Matches values less than (or equal to) a specified value
+- $in: Matches any of the values in an array
+- $nin: Matches none of the values in an array
+- $ne: Matches values not equal to a specified value
+- $exists: Matches documents that have the specified field
+
+Example queries:
+1. Find documents where age > 21:
+{ "age": { "$gt": 21 } }
+
+2. Find documents with specific status:
+{ "status": { "$in": ["active", "pending"] } }
+
+3. Find documents with existing email:
+{ "email": { "$exists": true } }
+
+4. Find documents with dates:
+// Using ISO date string format
+{ "createdAt": { "$gt": "2023-01-01T00:00:00Z" } }
+// Using ISODate syntax
+{ "createdAt": { "$gt": ISODate("2023-01-01T00:00:00Z") } }
+
+Use these patterns to construct MongoDB queries.`
       }
     ]
   };
@@ -1662,12 +2107,13 @@ function createSendProgress(progressToken, notify) {
     params: { progressToken, progress, total, message }
   });
 }
-function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false, allowServerJs = false, options = {}) {
+function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false, allowServerJs = false, options = {}, connections2, queryLimits) {
+  const defaultTarget = { client, db, isReadOnlyMode };
   const server = new Server(
     {
       name: "mongodb",
       title: "MongoDB MCP Server",
-      version: "3.0.2",
+      version: "3.2.0",
       description: "MCP server for MongoDB: query, aggregate, and manage collections with read-only mode, progress notifications, and cancellation",
       websiteUrl: "https://github.com/kiliczsh/mcp-mongo-server",
       ...options
@@ -1692,23 +2138,27 @@ function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false,
       signal: ctx.mcpReq.signal
     })
   );
-  server.setRequestHandler(
-    "resources/list",
-    (request, ctx) => handleListResourcesRequest({
+  server.setRequestHandler("resources/list", (request, ctx) => {
+    if (connections2?.named) {
+      return listNamedResources(
+        connections2,
+        request.params?.cursor,
+        ctx.mcpReq.signal
+      );
+    }
+    return handleListResourcesRequest({
       request,
       client,
       db,
       isReadOnlyMode,
       signal: ctx.mcpReq.signal
-    })
-  );
+    });
+  });
   server.setRequestHandler(
     "resources/read",
-    (request, ctx) => handleReadResourceRequest({
+    async (request, ctx) => handleReadResourceRequest({
       request,
-      client,
-      db,
-      isReadOnlyMode,
+      ...connections2 ? await connections2.resolve(resourceSelectors(request.params.uri)) : defaultTarget,
       signal: ctx.mcpReq.signal,
       sendProgress: createSendProgress(
         request.params._meta?.progressToken,
@@ -1723,6 +2173,9 @@ function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false,
       client,
       db,
       isReadOnlyMode,
+      connectionSelection: !!connections2,
+      hasWritableConnection: connections2?.list().some(({ readOnly }) => !readOnly),
+      queryLimits,
       signal: ctx.mcpReq.signal
     })
   );
@@ -1735,6 +2188,8 @@ function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false,
       isReadOnlyMode,
       allowCrossDb,
       allowServerJs,
+      connections: connections2,
+      queryLimits,
       signal: ctx.mcpReq.signal
     })
   );
@@ -1745,16 +2200,16 @@ function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false,
       client,
       db,
       isReadOnlyMode,
+      connectionSelection: !!connections2,
       signal: ctx.mcpReq.signal
     })
   );
   server.setRequestHandler(
     "prompts/get",
-    (request, ctx) => handleGetPromptRequest({
+    async (request, ctx) => handleGetPromptRequest({
       request,
-      client,
-      db,
-      isReadOnlyMode,
+      ...connections2 ? await connections2.resolve(request.params.arguments) : defaultTarget,
+      showTarget: !!connections2?.named,
       signal: ctx.mcpReq.signal,
       sendProgress: createSendProgress(
         request.params._meta?.progressToken,
@@ -1762,31 +2217,94 @@ function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false,
       )
     })
   );
-  server.setRequestHandler(
-    "resources/templates/list",
-    (request, ctx) => handleListResourceTemplatesRequest({
+  server.setRequestHandler("resources/templates/list", async (request, ctx) => {
+    const result = await handleListResourceTemplatesRequest({
       request,
       client,
       db,
       isReadOnlyMode,
       signal: ctx.mcpReq.signal
-    })
-  );
-  server.setRequestHandler(
-    "completion/complete",
-    (request, ctx) => handleCompletionRequest({
+    });
+    if (connections2?.named) {
+      result.resourceTemplates.push({
+        ...result.resourceTemplates[0],
+        name: "mongodb_connection_collection",
+        uriTemplate: "mongodb:///{collection}{?connectionId,database}"
+      });
+    }
+    return result;
+  });
+  server.setRequestHandler("completion/complete", async (request, ctx) => {
+    const { ref, argument, context } = request.params;
+    const selectors = {
+      ...context?.arguments,
+      ...ref.type === "ref/resource" ? resourceSelectors(ref.uri) : {}
+    };
+    if (connections2 && (argument.name === "connectionId" || argument.name === "database")) {
+      const candidates = argument.name === "connectionId" ? connections2.list().map(({ connectionId }) => connectionId) : await connections2.listDatabases(selectors.connectionId);
+      const matches = candidates.filter(
+        (value) => value.startsWith(argument.value)
+      );
+      return {
+        completion: {
+          values: matches.slice(0, 100),
+          total: matches.length,
+          hasMore: matches.length > 100
+        }
+      };
+    }
+    return handleCompletionRequest({
       request,
-      client,
-      db,
-      isReadOnlyMode,
+      ...connections2 ? await connections2.resolve(selectors) : defaultTarget,
       signal: ctx.mcpReq.signal
-    })
-  );
+    });
+  });
   return server;
 }
+async function listNamedResources(connections2, cursor, signal) {
+  const prefix = `${connections2.cursorScope}.`;
+  const offsetCursor = cursor?.slice(prefix.length);
+  const offset = decodeCursor(offsetCursor);
+  if (cursor !== void 0 && (!cursor.startsWith(prefix) || !Number.isSafeInteger(offset) || encodeCursor(offset) !== offsetCursor)) {
+    throw new ProtocolError4(
+      ProtocolErrorCode4.InvalidParams,
+      "Invalid resource cursor for the current connection configuration"
+    );
+  }
+  const resources = [];
+  for (const { connectionId, defaultDatabase } of connections2.list()) {
+    try {
+      signal?.throwIfAborted();
+      for (const database of await connections2.listDatabases(connectionId)) {
+        const { db } = await connections2.resolve({ connectionId, database });
+        const collections = await db.listCollections({}, { nameOnly: true }).toArray();
+        for (const name of collections.map(({ name: name2 }) => name2).sort()) {
+          if (name.startsWith("system.")) continue;
+          const query = connectionId === "default" && database === defaultDatabase ? "" : `?${new URLSearchParams({ connectionId, database })}`;
+          resources.push({
+            uri: `mongodb:///${encodeURIComponent(name)}${query}`,
+            name,
+            mimeType: "application/json",
+            description: `MongoDB collection: ${connectionId}/${database}/${name}`
+          });
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      throw new Error(
+        `Failed to list resources for MongoDB connection '${connectionId}'`
+      );
+    }
+  }
+  const { items, nextCursor } = paginate(resources, offsetCursor);
+  return {
+    resources: items,
+    ...nextCursor ? { nextCursor: prefix + nextCursor } : {}
+  };
+}
 
 // src/index.ts
-var mongoClient = null;
+var connections;
 async function main() {
   const args = process.argv.slice(2);
   let connectionUrl = "";
@@ -1835,34 +2353,14 @@ async function main() {
   if (!connectionUrl) {
     connectionUrl = process.env.MCP_MONGODB_URI || "";
   }
-  if (!connectionUrl) {
-    console.error(
-      "Please provide a MongoDB connection URL via command-line argument or MCP_MONGODB_URI environment variable"
-    );
-    console.error(
-      "Usage: command <mongodb-url> [--read-only|-r] [--transport stdio|http] [--port 3001]"
-    );
-    console.error(
-      "   or: MCP_MONGODB_URI=<mongodb-url> [MCP_MONGODB_READONLY=true] command"
-    );
-    process.exit(1);
-  }
-  if (!connectionUrl.startsWith("mongodb://") && !connectionUrl.startsWith("mongodb+srv://")) {
-    console.error(
-      "Invalid MongoDB connection URL. URL must start with 'mongodb://' or 'mongodb+srv://'"
-    );
-    process.exit(1);
-  }
   try {
-    const { client, db, isConnected, isReadOnlyMode } = await connectToMongoDB(
+    const queryLimits = readQueryLimits(process.env);
+    connections = new Connections(
       connectionUrl,
+      process.env.MCP_MONGODB_CONNECTIONS,
       readOnlyMode
     );
-    mongoClient = client;
-    if (!isConnected || !client || !db) {
-      console.error("Failed to connect to MongoDB");
-      process.exit(1);
-    }
+    const { client, db, isReadOnlyMode } = await connections.resolve();
     if (transportMode === "http") {
       await startHttpServer(
         client,
@@ -1870,6 +2368,8 @@ async function main() {
         isReadOnlyMode,
         allowCrossDb,
         allowServerJs,
+        connections,
+        queryLimits,
         port,
         allowedOrigins,
         jsonLimit,
@@ -1881,20 +2381,29 @@ async function main() {
         db,
         isReadOnlyMode,
         allowCrossDb,
-        allowServerJs
+        allowServerJs,
+        connections,
+        queryLimits
       );
     }
   } catch (error) {
-    console.error("Failed to connect to MongoDB:", error);
-    if (mongoClient) {
-      await mongoClient.close();
-    }
+    console.error("Failed to start MongoDB MCP server:", error);
+    await connections?.close();
     process.exit(1);
   }
 }
-async function startStdioServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs) {
+async function startStdioServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs, connections2, queryLimits) {
   serveStdio(
-    () => createServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs)
+    () => createServer(
+      client,
+      db,
+      isReadOnlyMode,
+      allowCrossDb,
+      allowServerJs,
+      {},
+      connections2,
+      queryLimits
+    )
   );
   console.warn("Server connected successfully via stdio");
 }
@@ -1921,7 +2430,7 @@ function bearerTokenValid(authorization, expected) {
   const wanted = Buffer.from(expected);
   return provided.length === wanted.length && timingSafeEqual(provided, wanted);
 }
-async function startHttpServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs, port, allowedOrigins, jsonLimit, authToken) {
+async function startHttpServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs, connections2, queryLimits, port, allowedOrigins, jsonLimit, authToken) {
   const app = createMcpExpressApp({ host: "0.0.0.0", jsonLimit });
   app.use((req, res, next) => {
     const start = Date.now();
@@ -1972,7 +2481,16 @@ async function startHttpServer(client, db, isReadOnlyMode, allowCrossDb, allowSe
     });
   }
   const mcpHandler = createMcpHandler(
-    (_ctx) => createServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs)
+    (_ctx) => createServer(
+      client,
+      db,
+      isReadOnlyMode,
+      allowCrossDb,
+      allowServerJs,
+      {},
+      connections2,
+      queryLimits
+    )
   );
   const nodeHandler = toNodeHandler(mcpHandler, {
     onerror: (error) => console.error("Error handling MCP request:", error)
@@ -1999,15 +2517,11 @@ async function startHttpServer(client, db, isReadOnlyMode, allowCrossDb, allowSe
   });
 }
 process.on("SIGINT", async () => {
-  if (mongoClient) {
-    await mongoClient.close();
-  }
+  await connections?.close();
   process.exit(0);
 });
 process.on("SIGTERM", async () => {
-  if (mongoClient) {
-    await mongoClient.close();
-  }
+  await connections?.close();
   process.exit(0);
 });
 main().catch((error) => {