mcp-mongo-server 3.1.0 → 3.2.1

package/build/index.js

@@ -176,6 +176,63 @@ function resourceSelectors(uri) {
   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 {
   ProtocolError as ProtocolError4,
@@ -184,1742 +241,1862 @@ import {
 } from "@modelcontextprotocol/server";
 
 // src/schemas/call.ts
-import { ProtocolError as ProtocolError2, ProtocolErrorCode as ProtocolErrorCode2 } 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,
-  connections: connections2,
-  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;
+  let collectionName;
+  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:'`
+      );
     }
+    collectionName = decodeURIComponent(url.pathname.replace(/^\//, ""));
+  } catch (error) {
+    if (error instanceof ProtocolError2) throw error;
+    throw new ProtocolError2(
+      ProtocolErrorCode2.InvalidParams,
+      `Invalid resource URI: ${request.params.uri}`
+    );
   }
-  if (args.sort) {
-    args.sort = parseSort(args.sort);
+  if (!collectionName) {
+    throw new ProtocolError2(
+      ProtocolErrorCode2.InvalidParams,
+      "Resource URI is missing a collection name"
+    );
   }
-  Object.assign(args, filteredArgs);
-  if (!connections2 || name !== "listConnections" && name !== "listDatabases") {
-    validateOperation(operation);
+  if (collectionName.toLowerCase().startsWith("system.")) {
+    throw new ProtocolError2(
+      ProtocolErrorCode2.InvalidParams,
+      "Access to system collections is not allowed"
+    );
   }
   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 (connections2 && name === "listConnections") {
-      return formatResponse({ connections: connections2.list() });
-    }
-    if (connections2 && name === "listDatabases") {
-      return formatResponse({
-        databases: await connections2.listDatabases(args.connectionId)
-      });
+    if (error instanceof Error) {
+      throw new Error(
+        `Failed to read collection ${collectionName}: ${error.message}`
+      );
     }
-    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();
-    return await executeOperation(
-      operation,
-      collection,
-      db,
-      isReadOnlyMode,
-      allowCrossDb,
-      allowServerJs,
-      args,
-      objectIdMode,
-      signal
-    );
-  } catch (error) {
-    if (error instanceof ProtocolError2 || signal?.aborted) {
-      throw error;
-    }
-    return toolExecutionError(
-      error instanceof Error ? error.message : "Unknown error"
+    throw new Error(
+      `Failed to read collection ${collectionName}: 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, 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 ProtocolError2(
-        ProtocolErrorCode2.InvalidParams,
-        `Unknown tool: ${operation}`
-      );
-  }
-}
-function validateOperation(operation) {
-  const validOperations = [
-    "query",
-    "aggregate",
-    "update",
-    "serverInfo",
-    "insert",
-    "createIndex",
-    "count",
-    "listCollections",
-    "convertTime"
-  ];
-  if (!validOperations.includes(operation)) {
-    throw new ProtocolError2(
-      ProtocolErrorCode2.InvalidParams,
-      `Unknown tool: ${operation}`
+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();
   }
-}
-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`
+  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}`
     );
-  }
-}
-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);
+      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}`
-    );
+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}`);
+    }
+    throw new Error("Failed to list collections: Unknown error");
   }
-  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
-          );
+}
+
+// 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"]
         }
-      } 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 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)) {
-        result[key] = new Date(dateString);
-      } else {
-        result[key] = value;
-      }
-    } else if (typeof value === "object" && value !== null) {
-      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);
-          } else 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;
+      },
+      {
+        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"
+            }
           }
-          return item;
-        });
-      } else {
-        result[key] = processObjectIdInFilter(
-          value,
-          objectIdMode,
-          depth + 1
-        );
-      }
-    } 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
+        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"]
         }
-      }).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)
+      },
+      {
+        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)
   );
-  if (!hasValidOperator) {
-    throw new Error(
-      "Update must include at least one valid update operator ($set, $unset, etc.)"
-    );
+  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(", ")}.`;
+    }
   }
-  try {
-    const options = {
-      upsert: !!upsert,
-      multi: !!multi
+  if (connectionSelection) {
+    const connectionId = {
+      type: "string",
+      description: "Configured connection ID. Defaults to default."
     };
-    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
-      }
+    const database = {
+      type: "string",
+      description: "Allowed database name. Defaults to the database in the connection URI."
     };
-    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
-      };
+    for (const tool of tools) {
+      if (tool.name !== "convertTime") {
+        tool.inputSchema.properties = {
+          ...tool.inputSchema.properties,
+          connectionId,
+          database
+        };
+      }
     }
-    return formatResponse(serverInfo);
-  } catch (error) {
-    return handleError(error, "get server information");
+    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;
 }
-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");
-  }
-  if (documents.length === 0) {
-    throw new Error("Documents array cannot be empty");
+
+// 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 (!documents.every(
-    (doc) => doc && typeof doc === "object" && !Array.isArray(doc)
-  )) {
-    throw new Error("Each document must be a valid MongoDB document object");
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = findAggOperator(item, operators, depth + 1);
+      if (found) return found;
+    }
+    return null;
   }
-  const processedDocuments = documents.map(
-    (doc) => processObjectIdInFilter(doc, objectIdMode)
-  );
-  try {
-    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) {
-    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
-      });
+  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 handleError(error, "insert", collection.collectionName);
   }
+  return null;
 }
-async function handleCreateIndex(collection, args, objectIdMode = "auto", signal) {
-  if (!collection) {
-    throw new Error("Collection is required for createIndex operation");
-  }
-  const { indexes, commitQuorum, writeConcern } = args;
-  if (!Array.isArray(indexes) || indexes.length === 0) {
-    throw new Error("Indexes must be a non-empty array");
-  }
-  if (writeConcern && (typeof writeConcern !== "object" || Array.isArray(writeConcern))) {
+function assertNoServerJs(value) {
+  const operator = findAggOperator(value, SERVER_JS_AGG_OPERATORS);
+  if (operator) {
     throw new Error(
-      "Write concern must be a valid MongoDB write concern object"
+      `Server-side JavaScript operator '${operator}' is disabled by the current server policy.`
     );
   }
-  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
-      );
-    }
-    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);
+}
+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 handleCount(collection, args, objectIdMode = "auto", allowServerJs = false, signal) {
-  if (!collection) {
-    throw new Error("Collection is required for count operation");
+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;
+    }
   }
-  const { query, limit, skip, hint, readConcern, maxTimeMS, collation } = args;
-  const countQuery = parseFilter(query, objectIdMode);
-  if (!allowServerJs) {
-    assertNoServerJs(countQuery);
+  if (args.sort) {
+    args.sort = parseSort(args.sort);
+  }
+  Object.assign(args, filteredArgs);
+  if (!connections2 || name !== "listConnections" && name !== "listDatabases") {
+    validateOperation(operation);
   }
   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];
+    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();
-    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);
+    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);
+      }
     }
-  } else {
-    throw new Error(
-      "convertTime 'input' must be a Unix timestamp (number) or a date string"
+    return await executeOperation(
+      operation,
+      collection,
+      db,
+      isReadOnlyMode,
+      allowCrossDb,
+      allowServerJs,
+      args,
+      objectIdMode,
+      queryLimits,
+      signal
     );
-  }
-  if (Number.isNaN(date.getTime())) {
-    throw new Error(
-      `Could not interpret '${String(input)}' as a date or Unix timestamp`
+  } catch (error) {
+    if (error instanceof ProtocolError3 || signal?.aborted) {
+      throw error;
+    }
+    return toolExecutionError(
+      error instanceof Error ? error.message : "Unknown error"
     );
   }
-  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 processedFilter = parseFilter(filter, objectIdMode);
-    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
+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}'`
+          );
+        }
       }
-    });
-  } catch (error) {
-    return handleError(error, "list collections");
+      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}`
+      );
   }
 }
-
-// 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")
+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}`
     );
-    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/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
-    );
+function validateCollection(collection) {
+  if (!collection.collectionName) {
+    throw new Error("Collection name cannot be empty");
   }
-  if (ref.type === "ref/resource") {
-    return handleResourceCompletion(
-      client,
-      db,
-      isReadOnlyMode,
-      ref.uri,
-      argument,
-      signal
+  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`
     );
   }
-  return emptyCompletionResult();
 }
-async function handlePromptCompletion(client, db, isReadOnlyMode, promptName, argument, signal) {
-  if (!promptName) {
-    return emptyCompletionResult();
+function parseSort(sort) {
+  if (!sort) return null;
+  if (typeof sort !== "object" || sort === null || Array.isArray(sort)) {
+    return null;
   }
-  if (argument.name === "collection") {
-    return await completeCollectionNames(
-      argument.value,
-      db,
-      isReadOnlyMode,
-      signal
-    );
+  const validSort = {};
+  for (const [key, value] of Object.entries(sort)) {
+    if (typeof value === "number" && (value === 1 || value === -1)) {
+      validSort[key] = value;
+    }
   }
-  return emptyCompletionResult();
+  return Object.keys(validSort).length > 0 ? validSort : null;
 }
-async function handleResourceCompletion(client, db, isReadOnlyMode, promptName, argument, signal) {
-  if (!promptName) {
-    return emptyCompletionResult();
+function parseFilter(filter, objectIdMode = "auto") {
+  if (!filter) {
+    return {};
   }
-  if (argument.name === "collection") {
-    return await completeCollectionNames(
-      argument.value,
-      db,
-      isReadOnlyMode,
-      signal
+  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
     );
   }
-  return emptyCompletionResult();
+  throw new Error("Query filter must be a plain object or ObjectId");
 }
-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 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
+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}`
     );
-    return {
-      completion: {
-        values: limitedResults,
-        total: matchingCollections.length,
-        hasMore: !!nextCursor
+  }
+  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;
+      }
+    } else if (typeof value === "object" && value !== null) {
+      if (Array.isArray(value)) {
+        result[key] = value.map((item) => {
+          if (typeof item === "string" && isObjectIdString(item) && (objectIdMode === "force" || objectIdMode === "auto" && isObjectIdField(key))) {
+            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(")")) {
+            const dateString = item.substring(8, item.length - 2);
+            return isISODateString(dateString) ? new Date(dateString) : item;
+          }
+          return item;
+        });
+      } else {
+        result[key] = processObjectIdInFilter(
+          value,
+          objectIdMode,
+          depth + 1
+        );
+      }
+    } 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)
       }
-    };
-  } catch (error) {
-    console.error("Error completing collection names:", error);
-    return emptyCompletionResult();
-  }
+    ]
+  };
 }
-function emptyCompletionResult() {
+function toolExecutionError(message) {
   return {
-    completion: {
-      values: [],
-      total: 0,
-      hasMore: false
-    }
+    content: [{ type: "text", text: message }],
+    isError: true
   };
 }
-
-// src/schemas/ping.ts
-async function handlePingRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal
-}) {
+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, limits = {}, signal) {
+  if (!collection) {
+    throw new Error("Collection is required for query operation");
+  }
+  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);
+  }
   try {
-    if (!client) {
-      throw new Error("MongoDB connection is not available");
+    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 pong = await db.command({ ping: 1 });
-    if (pong.ok !== 1) {
-      throw new Error(`MongoDB ping failed: ${pong.errmsg}`);
+    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");
     }
-    return {};
+    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({
+      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) {
-      throw new Error(`MongoDB ping failed: ${error.message}`);
-    }
-    throw new Error("MongoDB ping failed: Unknown error");
+    signal?.throwIfAborted();
+    return handleError(error, "query", collection.collectionName);
   }
 }
-
-// src/schemas/prompts.ts
-async function handleListPromptsRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal,
-  connectionSelection = false
-}) {
-  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
-          },
-          ...connectionSelection ? [
-            {
-              name: "connectionId",
-              description: "Configured MongoDB connection ID"
-            },
-            {
-              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");
+async function handleAggregate(collection, args, objectIdMode = "auto", isReadOnlyMode = false, allowCrossDb = false, allowServerJs = false, limits = {}, signal) {
+  if (!collection) {
+    throw new Error("Collection is required for aggregate operation");
   }
-  const collectionName = args.collection;
-  if (!collectionName) {
-    throw new Error("Collection name is required");
+  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 {
-    const collection = db.collection(collectionName);
-    if (collection.collectionName.startsWith("system.")) {
-      throw new Error("Access to system collections is not allowed");
+    if (explain) {
+      signal?.throwIfAborted();
+      const explainResult = await collection.aggregate(processedPipeline, {
+        explain: {
+          verbosity: explain
+        },
+        signal,
+        timeoutMS: limits.timeoutMS
+      }).toArray();
+      return formatResponse(explainResult);
     }
-    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");
+    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) {
     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)}`
-          }
-        },
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: "Provide insights about the collection's structure, data types, and basic statistics."
-          }
-        }
-      ]
+    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) {
-    const msg = error instanceof Error ? error.message : "Unknown error";
-    throw new Error(`Failed to analyze collection ${collectionName}: ${msg}`);
+    return handleError(error, "update", collection.collectionName);
   }
 }
-
-// src/schemas/resource.ts
-import {
-  ProtocolError as ProtocolError3,
-  ProtocolErrorCode as ProtocolErrorCode3
-} 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]}>`;
+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 "Array<mixed>";
-  }
-  if (typeof value === "object") {
-    return "Document";
+    return formatResponse(serverInfo);
+  } catch (error) {
+    return handleError(error, "get server information");
   }
-  return typeof value;
 }
-function inferSchemaFromSamples(documents) {
-  if (!documents || documents.length === 0) {
-    return { fields: [] };
+async function handleInsert(collection, args, objectIdMode = "auto", signal) {
+  if (!collection) {
+    throw new Error("Collection is required for insert 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 { documents, ordered, writeConcern, bypassDocumentValidation } = args;
+  if (!Array.isArray(documents)) {
+    throw new Error("Documents must be an 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 (documents.length === 0) {
+    throw new Error("Documents array cannot be empty");
   }
-  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 (!documents.every(
+    (doc) => doc && typeof doc === "object" && !Array.isArray(doc)
+  )) {
+    throw new Error("Each document must be a valid MongoDB document object");
   }
-  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: []
+  const processedDocuments = documents.map(
+    (doc) => processObjectIdInFilter(doc, objectIdMode)
+  );
+  try {
+    const options = {
+      ordered: ordered !== false,
+      // default to true if not specified
+      writeConcern,
+      bypassDocumentValidation
     };
-    if (fieldInfo.nestedSchema) {
-      result.nestedSchema = fieldInfo.nestedSchema;
-    }
-    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;
+    signal?.throwIfAborted();
+    const result = await collection.insertMany(
+      processedDocuments,
+      options
+    );
+    return formatResponse({
+      acknowledged: result.acknowledged,
+      insertedCount: result.insertedCount,
+      insertedIds: result.insertedIds
     });
-    result.examples = sampleValues;
-    return result;
-  });
-  return { fields };
+  } 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);
+  }
 }
-async function handleReadResourceRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal,
-  sendProgress
-}) {
-  let collectionName;
-  try {
-    const url = new URL(request.params.uri);
-    if (url.protocol !== "mongodb:") {
-      throw new ProtocolError3(
-        ProtocolErrorCode3.InvalidParams,
-        `Unsupported resource URI scheme '${url.protocol}': expected 'mongodb:'`
+async function handleCreateIndex(collection, args, objectIdMode = "auto", signal) {
+  if (!collection) {
+    throw new Error("Collection is required for createIndex operation");
+  }
+  const { indexes, commitQuorum, writeConcern } = args;
+  if (!Array.isArray(indexes) || indexes.length === 0) {
+    throw new Error("Indexes must be a non-empty array");
+  }
+  if (writeConcern && (typeof writeConcern !== "object" || Array.isArray(writeConcern))) {
+    throw new Error(
+      "Write concern must be a valid MongoDB write concern object"
+    );
+  }
+  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
       );
     }
-    collectionName = decodeURIComponent(url.pathname.replace(/^\//, ""));
-  } catch (error) {
-    if (error instanceof ProtocolError3) throw error;
-    throw new ProtocolError3(
-      ProtocolErrorCode3.InvalidParams,
-      `Invalid resource URI: ${request.params.uri}`
+    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);
   }
-  if (!collectionName) {
-    throw new ProtocolError3(
-      ProtocolErrorCode3.InvalidParams,
-      "Resource URI is missing a collection name"
-    );
+}
+async function handleCount(collection, args, objectIdMode = "auto", allowServerJs = false, signal) {
+  if (!collection) {
+    throw new Error("Collection is required for count operation");
   }
-  if (collectionName.startsWith("system.")) {
-    throw new ProtocolError3(
-      ProtocolErrorCode3.InvalidParams,
-      "Access to system collections is not allowed"
-    );
+  const { query, limit, skip, hint, readConcern, maxTimeMS, collation } = args;
+  const countQuery = parseFilter(query, objectIdMode);
+  if (!allowServerJs) {
+    assertNoServerJs(countQuery);
   }
   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");
-    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 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];
       }
     }
-    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)
-        }
-      ]
-    };
+    signal?.throwIfAborted();
+    const count = await collection.countDocuments(countQuery, options);
+    return formatResponse({
+      count,
+      ok: 1
+    });
   } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(
-        `Failed to read collection ${collectionName}: ${error.message}`
-      );
+    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);
     }
+  } else {
     throw new Error(
-      `Failed to read collection ${collectionName}: Unknown 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
+  });
 }
-async function handleListResourcesRequest({
-  request,
-  client,
-  db,
-  isReadOnlyMode,
-  signal
-}) {
+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);
     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 } : {}
-    };
+    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
+      }
+    });
   } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`Failed to list collections: ${error.message}`);
-    }
-    throw new Error("Failed to list collections: Unknown error");
+    return handleError(error, "list collections");
   }
 }
 
-// src/schemas/templates.ts
-async function handleListResourceTemplatesRequest({
+// src/schemas/completion.ts
+async function handleCompletionRequest({
   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.`
+  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 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 {
+      completion: {
+        values: limitedResults,
+        total: matchingCollections.length,
+        hasMore: !!nextCursor
       }
-    ]
+    };
+  } catch (error) {
+    console.error("Error completing collection names:", error);
+    return emptyCompletionResult();
+  }
+}
+function emptyCompletionResult() {
+  return {
+    completion: {
+      values: [],
+      total: 0,
+      hasMore: false
+    }
   };
 }
 
-// src/schemas/tools.ts
-async function handleListToolsRequest({
+// src/schemas/ping.ts
+async function handlePingRequest({
   request,
   client,
   db,
   isReadOnlyMode,
-  signal,
-  connectionSelection = false
+  signal
 }) {
-  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: "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"]
-        }
-      },
+  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/prompts.ts
+async function handleListPromptsRequest({
+  request,
+  client,
+  db,
+  isReadOnlyMode,
+  signal,
+  connectionSelection = false
+}) {
+  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: "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."
+            {
+              name: "database",
+              description: "Allowed MongoDB database name"
             }
-          }
-        }
+          ] : []
+        ]
       }
     ]
   };
-  const { tools } = result;
-  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
-        };
-      }
+}
+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");
     }
-    tools.push(
-      {
-        name: "listConnections",
-        description: "List configured connection IDs, default databases, and read-only policies.",
-        inputSchema: { type: "object", properties: {} }
-      },
+    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)}`
+          }
+        },
+        {
+          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: "listDatabases",
-        description: "List existing authorized databases on a configured connection.",
-        inputSchema: { type: "object", properties: { connectionId } }
+        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.`
       }
-    );
-  }
-  return result;
+    ]
+  };
 }
 
 // src/server.ts
@@ -1930,13 +2107,13 @@ function createSendProgress(progressToken, notify) {
     params: { progressToken, progress, total, message }
   });
 }
-function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false, allowServerJs = false, options = {}, connections2) {
+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.1.0",
+      version: "3.2.1",
       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
@@ -1997,6 +2174,8 @@ function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false,
       db,
       isReadOnlyMode,
       connectionSelection: !!connections2,
+      hasWritableConnection: connections2?.list().some(({ readOnly }) => !readOnly),
+      queryLimits,
       signal: ctx.mcpReq.signal
     })
   );
@@ -2010,6 +2189,7 @@ function createServer(client, db, isReadOnlyMode = false, allowCrossDb = false,
       allowCrossDb,
       allowServerJs,
       connections: connections2,
+      queryLimits,
       signal: ctx.mcpReq.signal
     })
   );
@@ -2174,6 +2354,7 @@ async function main() {
     connectionUrl = process.env.MCP_MONGODB_URI || "";
   }
   try {
+    const queryLimits = readQueryLimits(process.env);
     connections = new Connections(
       connectionUrl,
       process.env.MCP_MONGODB_CONNECTIONS,
@@ -2188,6 +2369,7 @@ async function main() {
         allowCrossDb,
         allowServerJs,
         connections,
+        queryLimits,
         port,
         allowedOrigins,
         jsonLimit,
@@ -2200,16 +2382,17 @@ async function main() {
         isReadOnlyMode,
         allowCrossDb,
         allowServerJs,
-        connections
+        connections,
+        queryLimits
       );
     }
   } catch (error) {
-    console.error("Failed to connect to MongoDB:", error);
+    console.error("Failed to start MongoDB MCP server:", error);
     await connections?.close();
     process.exit(1);
   }
 }
-async function startStdioServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs, connections2) {
+async function startStdioServer(client, db, isReadOnlyMode, allowCrossDb, allowServerJs, connections2, queryLimits) {
   serveStdio(
     () => createServer(
       client,
@@ -2218,7 +2401,8 @@ async function startStdioServer(client, db, isReadOnlyMode, allowCrossDb, allowS
       allowCrossDb,
       allowServerJs,
       {},
-      connections2
+      connections2,
+      queryLimits
     )
   );
   console.warn("Server connected successfully via stdio");
@@ -2246,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, connections2, 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();
@@ -2304,7 +2488,8 @@ async function startHttpServer(client, db, isReadOnlyMode, allowCrossDb, allowSe
       allowCrossDb,
       allowServerJs,
       {},
-      connections2
+      connections2,
+      queryLimits
     )
   );
   const nodeHandler = toNodeHandler(mcpHandler, {