{
  "schema_version": 1,
  "server_id": "mongodb",
  "package": "docker.io/mongodb/mongodb-mcp-server",
  "version": "3.2.2",
  "collected_at": "2026-11-05T01:58:18.441Z",
  "analyzed_at": "2026-11-05T01:58:18.441Z",
  "modelara_version": "v0.1.8",
  "fingerprint": "sha256:b8303b74545bc0f8b3812e41a8a1ed5351fd438d273bc3fcbde42f594cd33d19",
  "tool_count": 27,
  "interface": {
    "format": "modelara.inspect/v0",
    "capability_set": {
      "source": {
        "type": "mcp",
        "name": "MongoDB MCP Server",
        "version": "3.2.2",
        "protocol_version": "2025-11-25"
      },
      "discovered_at": "2026-11-05T01:58:18.107669301Z",
      "capabilities": [
        {
          "id": "mcp:MongoDB MCP Server/aggregate",
          "name": "aggregate",
          "title": "aggregate",
          "description": "Run an aggregation against a MongoDB collection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "aggregate"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "pipeline": {
                "description": "An array of aggregation stages to execute.\n\nIf the user has asked for a vector search, `$vectorSearch` **MUST** be the first stage\nof the pipeline (or the first stage of a `$unionWith` sub-pipeline only when explicitly\ncombining unrelated result sets — for hybrid full-text + vector search, use `$rankFusion`\nor `$scoreFusion` instead, see below).\n\nIf the user has asked for lexical/Atlas search, use `$search` instead of `$text`.\n### Usage Rules for `$vectorSearch`\n- **Index Type Detection:**\n  Use the collection-indexes tool to determine if the target field has a classic vector index (type: 'vector') or an auto-embed index (type: 'autoEmbed').\n- **Classic Vector Search (type: 'vector'):**\n  Use 'queryVector' with embeddings as an array of numbers.\n- **Auto-Embed Vector Search (type: 'autoEmbed'):**\n  Use 'query' - MongoDB automatically generates embeddings at query time. Do NOT use 'queryVector' or 'embeddingParameters' for auto-embed indexes.\n- **Unset embeddings:**\n  Unless the user explicitly requests the embeddings, add an `$unset` stage **at the end of the pipeline** to remove the embedding field and avoid context limits. **The $unset stage in this situation is mandatory**.\n- **Pre-filtering:**\n  If the user requests additional filtering, include filters in `$vectorSearch.filter` only for pre-filter fields in the vector index.\n  NEVER include fields in $vectorSearch.filter that are not part of the vector index.\n- **Post-filtering:**\n  For all remaining filters, add a $match stage after $vectorSearch.\n- If unsure which fields are filterable, use the collection-indexes tool to determine valid prefilter fields.\n- If no requested filters are valid prefilters, omit the filter key from $vectorSearch.\n\n### Usage Rules for `$search`\n- Include the index name, unless you know for a fact there's a default index. If unsure, use the collection-indexes tool to determine the index name.\n- The `$search` stage supports multiple operators, such as 'autocomplete', 'text', 'geoWithin', and others. Choose the appropriate operator based on the user's query. If unsure of the exact syntax, consult the MongoDB Atlas Search documentation, which can be found here: https://www.mongodb.com/docs/atlas/atlas-search/operators-and-collectors/\n\n### Usage Rules for `$rankFusion` and `$scoreFusion` (Hybrid Search)\nUse these stages when the user wants to combine full-text (`$search`) and vector\n(`$vectorSearch`) retrieval into a single fused result set. **Prefer native\nfusion over a `$unionWith` + `$group` workaround** — the workaround averages\nincompatible score scales and produces wrong rankings.\n\n**Which stage to use:**\n- `$rankFusion` (MongoDB 8.0+) — Reciprocal Rank Fusion. The recommended default.\n  Normalizes scores across incompatible scales automatically. No score tuning needed.\n- `$scoreFusion` (MongoDB 8.2+) — Score-based fusion. Use when the user needs explicit\n  per-pipeline weights, score normalisation (sigmoid / minMaxScaler), or a custom\n  combination expression.\n\n**Construction rules:**\n- `$rankFusion` / `$scoreFusion` MUST be the first stage of the top-level pipeline.\n- Sub-pipelines go inside `input.pipelines` as a named map (not an array). Each name\n  must be non-empty, must not start with `$`, and must not contain `.` or null bytes.\n- Allowed stages inside sub-pipelines: `$search`, `$vectorSearch`, `$match`, `$sort`,\n  `$geoNear`, `$skip`, `$limit`. `$project` and `$unset` are NOT allowed inside sub-pipelines.\n- Do field shaping (`$project` / `$unset`) only AFTER the fusion stage, at the root.\n- Both a vectorSearch (or autoEmbed) index AND a search (lexical) index must exist on\n  the collection. Use the collection-indexes tool to confirm both before running a hybrid query.\n- Add a `$limit` stage after the fusion stage to cap the final result set.\n- Add `$unset` at the end to remove embedding fields and avoid context bloat.\n\n### Usage Rules for `$rerank` (Native Reranking)\nUse this stage when the user wants to reorder a set of candidate documents using a cross-encoder reranker model.\n\n**Construction rules:**\n- `$rerank` can be any stage in the pipeline on an Atlas cluster running MongoDB 8.3 or higher.\n- It is recommended to use `$rerank` after a sorted pipeline, e.g. `$search`, `$vectorSearch`, `$rankFusion`, `$scoreFusion`, or [`$match`, `$sort`].\n- $rerank must be enabled via the Native Reranking Project Setting\n- Set `numDocsToRerank` as the number of documents passed into `$rerank`. This will also limit the number of documents returned by `$rerank`\n- Set `path` as a field name or an array of field names that exist in all documents. Use `$match` or `$set` before `$rerank` to validate no fields are missing.\n- Add `$addFields` after `$rerank` to retrieve the reranker score.\n\n**`$rerank` example (recommended default):**\n```javascript\n[\n  {\n    $match: {\n      description: { $exists: true },\n      name: { $exists: true }\n    }\n  },\n  {\n    $sort: {\n      lastUpdated: -1\n    }\n  },\n  {\n    $rerank: {\n      query: {\n        text: \"query text including instructions\"\n      },\n      model: \"rerank-2.5\",\n      numDocsToRerank: 100,\n      path: [\"description\", \"name\"]\n    }\n  },\n  {\n    $addFields: {\n      rerankScore: { $meta: \"score\" }\n    }\n  }\n]\n```\n",
                "items": {
                  "anyOf": [
                    {
                      "properties": {
                        "$vectorSearch": {
                          "anyOf": [
                            {
                              "description": "Classic vector search using 'queryVector'. Use this when the indexed field has a classic vector index (type: 'vector'). Note to LLM: Use the collection-indexes tool to verify the target field has a classic vector index before using 'queryVector'.",
                              "properties": {
                                "exact": {
                                  "default": false,
                                  "description": "When true, uses an ENN algorithm, otherwise uses ANN. Using ENN is not compatible with numCandidates, in that case, numCandidates must be left empty.",
                                  "type": "boolean"
                                },
                                "filter": {
                                  "additionalProperties": {},
                                  "description": "MQL filter that can only use filter fields from the index definition. Note to LLM: If unsure, use the `collection-indexes` tool to learn which fields can be used for filtering.",
                                  "properties": {},
                                  "type": "object"
                                },
                                "index": {
                                  "description": "Name of the index, as retrieved from the `collection-indexes` tool.",
                                  "type": "string"
                                },
                                "limit": {
                                  "default": 10,
                                  "exclusiveMinimum": 0,
                                  "maximum": 9007199254740991,
                                  "type": "integer"
                                },
                                "numCandidates": {
                                  "description": "Number of candidates for the ANN algorithm. Mandatory when exact is false.",
                                  "exclusiveMinimum": 0,
                                  "maximum": 9007199254740991,
                                  "type": "integer"
                                },
                                "path": {
                                  "description": "Field, in dot notation, where to search. There must be a vector search index for that field.",
                                  "type": "string"
                                },
                                "queryVector": {
                                  "description": "The vector embeddings to search for when using classic vector search indexes (type: 'vector'). Provide embeddings as an array of numbers. Use this for classic vector indexes. For auto-embed indexes (type: 'autoEmbed'), use 'query' instead.",
                                  "items": {
                                    "type": "number"
                                  },
                                  "type": "array"
                                }
                              },
                              "required": [
                                "index",
                                "path",
                                "queryVector"
                              ],
                              "type": "object"
                            },
                            {
                              "description": "Auto-embed vector search using 'query'. Use this when the indexed field has an auto-embed index (type: 'autoEmbed'). Note to LLM: Use the collection-indexes tool to verify the target field has an auto-embed index before using 'query'.",
                              "properties": {
                                "exact": {
                                  "default": false,
                                  "description": "When true, uses an ENN algorithm, otherwise uses ANN. Using ENN is not compatible with numCandidates, in that case, numCandidates must be left empty.",
                                  "type": "boolean"
                                },
                                "filter": {
                                  "additionalProperties": {},
                                  "description": "MQL filter that can only use filter fields from the index definition. Note to LLM: If unsure, use the `collection-indexes` tool to learn which fields can be used for filtering.",
                                  "properties": {},
                                  "type": "object"
                                },
                                "index": {
                                  "description": "Name of the index, as retrieved from the `collection-indexes` tool.",
                                  "type": "string"
                                },
                                "limit": {
                                  "default": 10,
                                  "exclusiveMinimum": 0,
                                  "maximum": 9007199254740991,
                                  "type": "integer"
                                },
                                "model": {
                                  "description": "The embedding model to use for generating embeddings from the query text. If not specified, defaults to the model configured in the auto-embed index definition.",
                                  "enum": [
                                    "voyage-4",
                                    "voyage-4-large",
                                    "voyage-4-lite",
                                    "voyage-code-3"
                                  ],
                                  "type": "string"
                                },
                                "numCandidates": {
                                  "description": "Number of candidates for the ANN algorithm. Mandatory when exact is false.",
                                  "exclusiveMinimum": 0,
                                  "maximum": 9007199254740991,
                                  "type": "integer"
                                },
                                "path": {
                                  "description": "Field, in dot notation, where to search. There must be a vector search index for that field.",
                                  "type": "string"
                                },
                                "query": {
                                  "description": "The query to search for when using auto-embed indexes (type: 'autoEmbed'). MongoDB will automatically generate embeddings for the text at query time. Use this for auto-embed indexes, not 'queryVector'.",
                                  "properties": {
                                    "text": {
                                      "description": "The text query to search for.",
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "text"
                                  ],
                                  "type": "object"
                                }
                              },
                              "required": [
                                "index",
                                "path",
                                "query"
                              ],
                              "type": "object"
                            }
                          ]
                        }
                      },
                      "required": [
                        "$vectorSearch"
                      ],
                      "type": "object"
                    },
                    {
                      "additionalProperties": {},
                      "properties": {},
                      "type": "object"
                    }
                  ]
                },
                "type": "array"
              },
              "responseBytesLimit": {
                "default": 1048576,
                "description": "The maximum number of bytes to return in the response. This value is capped by the server's configured maximum and cannot be exceeded.",
                "type": "number"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "pipeline"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "appliedLimits": {
                "description": "The limits applied to the aggregation pipeline",
                "items": {
                  "enum": [
                    "config.maxDocumentsPerQuery",
                    "config.maxBytesPerQuery",
                    "tool.responseBytesLimit"
                  ],
                  "type": "string"
                },
                "type": "array"
              },
              "count": {
                "anyOf": [
                  {
                    "type": "number"
                  },
                  {
                    "const": "indeterminate",
                    "type": "string"
                  }
                ],
                "description": "The total number of documents returned by the aggregation pipeline"
              },
              "documents": {
                "description": "The documents returned by the aggregation pipeline",
                "items": {},
                "type": "array"
              }
            },
            "required": [
              "documents",
              "count",
              "appliedLimits"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:05974351b2b274a1218457cbdb889725d38c1fd69f5f475a0e153d89b53577d6"
        },
        {
          "id": "mcp:MongoDB MCP Server/aggregate-db",
          "name": "aggregate-db",
          "title": "aggregate-db",
          "description": "Run an aggregation against a MongoDB database",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "aggregate-db"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "pipeline": {
                "description": "An array of aggregation stages to execute. The first stage must be a database-level aggregation stage (one of `$changeStream`, `$currentOp`, `$documents`, `$listLocalSessions`, `$queryStats`). https://www.mongodb.com/docs/manual/reference/mql/aggregation-stages/#db.aggregate---stages",
                "items": {
                  "additionalProperties": {},
                  "properties": {},
                  "type": "object"
                },
                "minItems": 1,
                "type": "array"
              },
              "responseBytesLimit": {
                "default": 1048576,
                "description": "The maximum number of bytes to return in the response. This value is capped by the server's configured maximum and cannot be exceeded.",
                "type": "number"
              }
            },
            "required": [
              "connectionId",
              "database",
              "pipeline"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "aggResultsCount": {
                "description": "The total number of documents returned by the aggregation pipeline",
                "type": "number"
              },
              "appliedLimits": {
                "description": "The limits applied to the aggregation pipeline",
                "items": {
                  "enum": [
                    "config.maxDocumentsPerQuery",
                    "config.maxBytesPerQuery",
                    "tool.responseBytesLimit"
                  ],
                  "type": "string"
                },
                "type": "array"
              },
              "documents": {
                "description": "The documents returned by the aggregation pipeline",
                "items": {},
                "type": "array"
              }
            },
            "required": [
              "documents",
              "appliedLimits"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:77941db854397d18be39acad9b65db2e3fe0fb01e76fa9de29ca53e9e4c9349d"
        },
        {
          "id": "mcp:MongoDB MCP Server/collection-indexes",
          "name": "collection-indexes",
          "title": "collection-indexes",
          "description": "Describe the indexes for a collection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "collection-indexes"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "classicIndexes": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "key": {
                      "additionalProperties": {},
                      "propertyNames": {
                        "type": "string"
                      },
                      "type": "object"
                    },
                    "name": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "name",
                    "key"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "classicIndexesCount": {
                "type": "number"
              },
              "searchIndexes": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "latestDefinition": {
                      "additionalProperties": {},
                      "propertyNames": {
                        "type": "string"
                      },
                      "type": "object"
                    },
                    "name": {
                      "type": "string"
                    },
                    "queryable": {
                      "type": "boolean"
                    },
                    "status": {
                      "type": "string"
                    },
                    "type": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "name",
                    "type",
                    "status",
                    "queryable",
                    "latestDefinition"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "searchIndexesCount": {
                "type": "number"
              }
            },
            "required": [
              "classicIndexes",
              "searchIndexes",
              "classicIndexesCount",
              "searchIndexesCount"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:16bf5cc8e1243b3690b8799e4c599087fd6152e5d14b2622ff2135cc6e8258a3"
        },
        {
          "id": "mcp:MongoDB MCP Server/collection-schema",
          "name": "collection-schema",
          "title": "collection-schema",
          "description": "Describe the schema for a collection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "collection-schema"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "responseBytesLimit": {
                "default": 1048576,
                "description": "The maximum number of bytes to return in the response. This value is capped by the server's configured maximum and cannot be exceeded.",
                "type": "number"
              },
              "sampleSize": {
                "default": 50,
                "description": "Number of documents to sample for schema inference",
                "type": "number"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "fieldsCount": {
                "type": "number"
              },
              "schema": {
                "additionalProperties": {},
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              }
            },
            "required": [
              "schema",
              "fieldsCount"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:2c850037323cdea9a314696ae3965111375e00f72c442edaff328fad4a138ddd"
        },
        {
          "id": "mcp:MongoDB MCP Server/collection-storage-size",
          "name": "collection-storage-size",
          "title": "collection-storage-size",
          "description": "Gets the size of the collection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "collection-storage-size"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "size": {
                "type": "number"
              },
              "units": {
                "type": "string"
              }
            },
            "required": [
              "size",
              "units"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:6e414e5fbb7eabd07fd2f0382471c3cf8cbd4ffc0c5bc7fea312c5e2916c75b3"
        },
        {
          "id": "mcp:MongoDB MCP Server/connect",
          "name": "connect",
          "title": "connect",
          "description": "Connect to a MongoDB instance and get back a connectionId to pass to the other MongoDB tools. Each call establishes a new, independent connection — multiple connections can be active at the same time.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "connect"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionName": {
                "description": "Optional short label for the connection (stored slugified with a short suffix, e.g. \"staging\" becomes staging-<suffix>). Shown in connection listings; helpful for telling multiple connections apart.",
                "type": "string"
              },
              "connectionString": {
                "description": "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
                "type": "string"
              }
            },
            "required": [
              "connectionString"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "type": "string"
              }
            },
            "required": [
              "connectionId"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:cbd7d178714c5b850d3576b9bc45229bc27d7859a1048dc933754a7665b85ad4"
        },
        {
          "id": "mcp:MongoDB MCP Server/count",
          "name": "count",
          "title": "count",
          "description": "Gets the number of documents in a MongoDB collection using db.collection.count() and query as an optional filter parameter",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "count"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "query": {
                "additionalProperties": {},
                "description": "A filter/query parameter. Allows users to filter the documents to count. Matches the syntax of the filter argument of db.collection.count().",
                "properties": {},
                "type": "object"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "count": {
                "description": "The number of documents in the collection",
                "type": "number"
              }
            },
            "required": [
              "count"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:1a4c3bd63c6c57d7f8f89c5c05586f5d19d4332a68110b5602cb210f8a5b46d2"
        },
        {
          "id": "mcp:MongoDB MCP Server/create-collection",
          "name": "create-collection",
          "title": "create-collection",
          "description": "Creates a new collection in a database. If the database doesn't exist, it will be created automatically.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "create-collection"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "type": "string"
              },
              "created": {
                "type": "boolean"
              },
              "database": {
                "type": "string"
              }
            },
            "required": [
              "database",
              "collection",
              "created"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:745c06d8ae1715098c34198be9fcdb2b7368d5505264ff6271d086e3e91d88b2"
        },
        {
          "id": "mcp:MongoDB MCP Server/create-index",
          "name": "create-index",
          "title": "create-index",
          "description": "Create an index for a collection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "create-index"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "definition": {
                "description": "The index definition. Use 'classic' for standard indexes, 'vectorSearch' for vector search indexes, and 'search' for Atlas Search (lexical) indexes.",
                "items": {
                  "oneOf": [
                    {
                      "description": "Definition for a MongoDB index (e.g. ascending/descending/geospatial/text).",
                      "properties": {
                        "keys": {
                          "additionalProperties": {
                            "anyOf": [
                              {
                                "const": 1,
                                "type": "number"
                              },
                              {
                                "const": -1,
                                "type": "number"
                              },
                              {
                                "const": "2d",
                                "type": "string"
                              },
                              {
                                "const": "2dsphere",
                                "type": "string"
                              },
                              {
                                "const": "text",
                                "type": "string"
                              },
                              {
                                "const": "geoHaystack",
                                "type": "string"
                              },
                              {
                                "const": "hashed",
                                "type": "string"
                              }
                            ],
                            "description": "The index key and its direction"
                          },
                          "description": "The index definition",
                          "propertyNames": {
                            "type": "string"
                          },
                          "type": "object"
                        },
                        "type": {
                          "const": "classic",
                          "type": "string"
                        }
                      },
                      "required": [
                        "type",
                        "keys"
                      ],
                      "type": "object"
                    },
                    {
                      "description": "Definition for a Vector Search index.",
                      "properties": {
                        "fields": {
                          "description": "Definitions for the vector, autoEmbed and filter fields to index, one definition per document. Use 'vector' when user specifies a dedicated field that could contain vector embeddings. Use 'autoEmbed' when user wants MongoDB to automatically generate and manage embeddings internally from a text field (no separate embeddings field). Use 'filter' for additional fields to filter on. At least one 'vector' or 'autoEmbed' type field definition is required.",
                          "items": {
                            "oneOf": [
                              {
                                "additionalProperties": false,
                                "description": "Definition for a field that will be used for pre-filtering results.",
                                "properties": {
                                  "path": {
                                    "description": "Name of the field to index. For nested fields, use dot notation to specify path to embedded fields",
                                    "type": "string"
                                  },
                                  "type": {
                                    "const": "filter",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "type",
                                  "path"
                                ],
                                "type": "object"
                              },
                              {
                                "additionalProperties": false,
                                "description": "Definition for a field that contains vector embeddings. Use this type when the field you're indexing is supposed to store vector embeddings or when the user have specified one of the relevant parameters.",
                                "properties": {
                                  "numDimensions": {
                                    "default": 1024,
                                    "description": "Number of vector dimensions that MongoDB Vector Search enforces at index-time and query-time",
                                    "maximum": 8192,
                                    "minimum": 1,
                                    "type": "number"
                                  },
                                  "path": {
                                    "description": "Name of the field containing vector embeddings as arrays of numbers. This must be a dedicated embeddings field, separate from any source text field, if any. For nested fields, use dot notation to specify path to embedded fields.",
                                    "type": "string"
                                  },
                                  "quantization": {
                                    "default": "none",
                                    "description": "Type of automatic vector quantization for your vectors. Use this setting only if your embeddings are float or double vectors.",
                                    "enum": [
                                      "none",
                                      "scalar",
                                      "binary"
                                    ],
                                    "type": "string"
                                  },
                                  "similarity": {
                                    "default": "euclidean",
                                    "description": "Vector similarity function to use to search for top K-nearest neighbors. You can set this field only for vector-type fields.",
                                    "enum": [
                                      "cosine",
                                      "euclidean",
                                      "dotProduct"
                                    ],
                                    "type": "string"
                                  },
                                  "type": {
                                    "const": "vector",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "type",
                                  "path"
                                ],
                                "type": "object"
                              },
                              {
                                "additionalProperties": false,
                                "description": "Definition for a field containing source text from which embeddings will be automatically generated and managed by MongoDB at indexing time. Use this type when you want MongoDB to handle all embedding generation and storage internally. If the user specifies a dedicated field name for storing embeddings, use 'vector' type instead.",
                                "properties": {
                                  "modality": {
                                    "description": "The data type / modality of the source content in the indexed field. Currently only 'text' is supported.",
                                    "enum": [
                                      "text"
                                    ],
                                    "type": "string"
                                  },
                                  "model": {
                                    "description": "Voyage embedding model to use for automatically generating embeddings from the source text in the indexed field.",
                                    "enum": [
                                      "voyage-4",
                                      "voyage-4-large",
                                      "voyage-4-lite",
                                      "voyage-code-3"
                                    ],
                                    "type": "string"
                                  },
                                  "path": {
                                    "description": "Name of the field containing the source text from which embeddings will be automatically generated by MongoDB. This should be the text field itself, NOT a separate embeddings field containing the vector embeddings. For nested fields, use dot notation to specify the path to embedded fields.",
                                    "type": "string"
                                  },
                                  "type": {
                                    "const": "autoEmbed",
                                    "type": "string"
                                  }
                                },
                                "required": [
                                  "type",
                                  "path",
                                  "model",
                                  "modality"
                                ],
                                "type": "object"
                              }
                            ]
                          },
                          "minItems": 1,
                          "type": "array"
                        },
                        "type": {
                          "const": "vectorSearch",
                          "type": "string"
                        }
                      },
                      "required": [
                        "type",
                        "fields"
                      ],
                      "type": "object"
                    },
                    {
                      "additionalProperties": {},
                      "description": "Definition for an Atlas Search (lexical) index. Use this only if user explicitly asked for creating an Atlas search index or simply a search index.\n\nThis definition also accepts the following top-level fields, which are forwarded as-is and are not exhaustively typed here:\n- `analyzers`: array of custom analyzer definitions, e.g. `{ name: 'myAnalyzer', tokenizer: { type: 'standard' }, tokenFilters: [{ type: 'lowercase' }], charFilters: [{ type: 'htmlStrip' }] }`. Reference a custom analyzer by its `name` from a field's `analyzer`/`searchAnalyzer` option, instead of a built-in `lucene.*` analyzer. Tokenizer types include `standard`, `keyword`, `whitespace`, `nGram`, `edgeGram`, `regexSplit`, `regexCaptureGroup`, `uaxUrlEmail`. Token filter types include `lowercase`, `stopword`, `snowballStemming`, `asciiFolding`, `nGram`, `shingle`, `trim`, among others.\n- `synonyms`: array of synonym mappings, e.g. `{ name: 'mySynonyms', source: { collection: 'synonymsCollectionName' }, analyzer: 'lucene.standard' }`. The `analyzer` should match the analyzer used on the field(s) being searched.\n- `storedSource`: controls which fields are stored on search nodes for fast retrieval without a round trip to the database. `true` stores all fields, `false` (default) stores none, `{ include: ['fieldA', 'fieldB'] }` stores only the listed fields, `{ exclude: ['fieldC'] }` stores all except the listed fields.\n- `typeSets`: array of named field-type sets for use with `mappings.dynamic`, e.g. `{ name: 'myTypeSet', types: [{ type: 'string' }, { type: 'number' }] }`, to restrict dynamic mapping to only the listed types instead of every dynamically indexable type.\n",
                      "properties": {
                        "analyzer": {
                          "default": "lucene.standard",
                          "description": "The analyzer to use for the index. Can be one of the built-in lucene analyzers (`lucene.standard`, `lucene.simple`, `lucene.whitespace`, `lucene.keyword`), a language-specific analyzer, such as `lucene.cjk` or `lucene.czech`, or a custom analyzer defined by name in `analyzers`.",
                          "type": "string"
                        },
                        "mappings": {
                          "additionalProperties": {},
                          "description": "Document describing the index to create. `fields` is required and must define at least one field when `dynamic` is `false` (the default). When `dynamic` is `true` or a typeSet object, `fields` may still be provided to index additional fields explicitly.",
                          "properties": {
                            "dynamic": {
                              "anyOf": [
                                {
                                  "type": "boolean"
                                },
                                {
                                  "additionalProperties": false,
                                  "properties": {
                                    "typeSet": {
                                      "description": "Name of a type set defined in this index's `typeSets`.",
                                      "type": "string"
                                    }
                                  },
                                  "required": [
                                    "typeSet"
                                  ],
                                  "type": "object"
                                }
                              ],
                              "default": false,
                              "description": "Enables or disables dynamic mapping of fields for this index. If set to true, Atlas Search recursively indexes all dynamically indexable fields. If set to false, you must specify individual fields to index using mappings.fields. Can also be set to `{ typeSet: '<name>' }` to reference a named entry in this index's `typeSets`, restricting dynamic mapping to only the field types listed in that type set."
                            },
                            "fields": {
                              "additionalProperties": {
                                "description": "The field index definition. It must contain the field type (e.g. `{ type: 'string' }`), as well as any additional options for that field type (e.g. `analyzer`). Field types include `autocomplete`, `boolean`, `date`, `dateFacet`, `document`, `embeddedDocuments`, `geo`, `number`, `numberFacet`, `objectId`, `string`, `stringFacet`, `token`, `uuid`. Provide an array of field definitions instead of a single object to index the same field as multiple types, e.g. `[{ type: 'string' }, { type: 'autocomplete' }]`."
                              },
                              "description": "The field mapping definitions. If `dynamic` is set to `false`, this is required.",
                              "propertyNames": {
                                "description": "The field name",
                                "type": "string"
                              },
                              "type": "object"
                            }
                          },
                          "type": "object"
                        },
                        "numPartitions": {
                          "anyOf": [
                            {
                              "const": "1",
                              "type": "string"
                            },
                            {
                              "const": "2",
                              "type": "string"
                            },
                            {
                              "const": "4",
                              "type": "string"
                            }
                          ],
                          "default": "1",
                          "description": "Specifies the number of sub-indexes to create if the document count exceeds two billion. If omitted, defaults to 1."
                        },
                        "type": {
                          "const": "search",
                          "type": "string"
                        }
                      },
                      "required": [
                        "type",
                        "mappings"
                      ],
                      "type": "object"
                    }
                  ]
                },
                "type": "array"
              },
              "name": {
                "description": "The name of the index",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "definition"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "type": "string"
              },
              "database": {
                "type": "string"
              },
              "indexName": {
                "type": "string"
              },
              "indexType": {
                "enum": [
                  "classic",
                  "vectorSearch",
                  "search"
                ],
                "type": "string"
              }
            },
            "required": [
              "database",
              "collection",
              "indexName",
              "indexType"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:fbef3fc747f455521545bc2c3587e7503225249ddf3bcce3e656e4672e97a062"
        },
        {
          "id": "mcp:MongoDB MCP Server/db-stats",
          "name": "db-stats",
          "title": "db-stats",
          "description": "Returns statistics that reflect the use state of a single database",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "db-stats"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "stats": {
                "additionalProperties": {},
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              }
            },
            "required": [
              "stats"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:1ea29533a337ecc06fc4f38983b4f615c113f5e02c02137df29815f927764ed5"
        },
        {
          "id": "mcp:MongoDB MCP Server/delete-many",
          "name": "delete-many",
          "title": "delete-many",
          "description": "Removes all documents that match the filter from a MongoDB collection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "delete-many"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "filter": {
                "additionalProperties": {},
                "description": "The query filter, specifying the deletion criteria. Matches the syntax of the filter argument of db.collection.deleteMany()",
                "properties": {},
                "type": "object"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "type": "string"
              },
              "database": {
                "type": "string"
              },
              "deletedCount": {
                "type": "number"
              }
            },
            "required": [
              "database",
              "collection",
              "deletedCount"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:468fb966b43dcfff12508134bf61a26dbafce3767c9d4d912374be385f2e2468"
        },
        {
          "id": "mcp:MongoDB MCP Server/disconnect",
          "name": "disconnect",
          "title": "disconnect",
          "description": "Close a MongoDB connection and revoke its connectionId.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "disconnect"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "description": "The connectionId to disconnect.",
                "type": "string"
              }
            },
            "required": [
              "connectionId"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "outcome": {
                "enum": [
                  "removed",
                  "disconnected"
                ],
                "type": "string"
              }
            },
            "required": [
              "outcome"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:d0cf202a3e1602a4e88af5acab1ff652895df5c6bf2dc3f77587e905566df17c"
        },
        {
          "id": "mcp:MongoDB MCP Server/drop-collection",
          "name": "drop-collection",
          "title": "drop-collection",
          "description": "Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "drop-collection"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "type": "string"
              },
              "database": {
                "type": "string"
              },
              "dropped": {
                "type": "boolean"
              }
            },
            "required": [
              "database",
              "collection",
              "dropped"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:aa3a55851d376aa20d0c0831a298358ceac501d23d8bb58249a1e59d7ad38020"
        },
        {
          "id": "mcp:MongoDB MCP Server/drop-database",
          "name": "drop-database",
          "title": "drop-database",
          "description": "Removes the specified database, deleting the associated data files",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "drop-database"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "database": {
                "type": "string"
              },
              "dropped": {
                "type": "boolean"
              }
            },
            "required": [
              "database",
              "dropped"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:e71cfece872149dae7dc00e52894db12c103e0ea253e1ddb93f24c27a2d7d91d"
        },
        {
          "id": "mcp:MongoDB MCP Server/drop-index",
          "name": "drop-index",
          "title": "drop-index",
          "description": "Drop an index for the provided database and collection.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "drop-index"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "indexName": {
                "description": "The name of the index to be dropped.",
                "minLength": 1,
                "type": "string"
              },
              "type": {
                "description": "The type of index to be deleted. Use 'classic' for standard indexes and 'search' for atlas search and vector search indexes.",
                "enum": [
                  "classic",
                  "search"
                ],
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "indexName",
              "type"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "type": "string"
              },
              "database": {
                "type": "string"
              },
              "dropped": {
                "type": "boolean"
              },
              "indexName": {
                "type": "string"
              }
            },
            "required": [
              "database",
              "collection",
              "indexName",
              "dropped"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:f950925ddcba3cc57279ddd9c244d2707daf8c239e76659ff4053970bdae47c2"
        },
        {
          "id": "mcp:MongoDB MCP Server/explain",
          "name": "explain",
          "title": "explain",
          "description": "Returns statistics describing the execution of the winning plan chosen by the query optimizer for the evaluated method",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "explain"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "method": {
                "description": "The method and its arguments to run",
                "items": {
                  "oneOf": [
                    {
                      "properties": {
                        "arguments": {
                          "properties": {
                            "pipeline": {
                              "description": "An array of aggregation stages to execute.\n\nIf the user has asked for a vector search, `$vectorSearch` **MUST** be the first stage\nof the pipeline (or the first stage of a `$unionWith` sub-pipeline only when explicitly\ncombining unrelated result sets — for hybrid full-text + vector search, use `$rankFusion`\nor `$scoreFusion` instead, see below).\n\nIf the user has asked for lexical/Atlas search, use `$search` instead of `$text`.\n### Usage Rules for `$vectorSearch`\n- **Index Type Detection:**\n  Use the collection-indexes tool to determine if the target field has a classic vector index (type: 'vector') or an auto-embed index (type: 'autoEmbed').\n- **Classic Vector Search (type: 'vector'):**\n  Use 'queryVector' with embeddings as an array of numbers.\n- **Auto-Embed Vector Search (type: 'autoEmbed'):**\n  Use 'query' - MongoDB automatically generates embeddings at query time. Do NOT use 'queryVector' or 'embeddingParameters' for auto-embed indexes.\n- **Unset embeddings:**\n  Unless the user explicitly requests the embeddings, add an `$unset` stage **at the end of the pipeline** to remove the embedding field and avoid context limits. **The $unset stage in this situation is mandatory**.\n- **Pre-filtering:**\n  If the user requests additional filtering, include filters in `$vectorSearch.filter` only for pre-filter fields in the vector index.\n  NEVER include fields in $vectorSearch.filter that are not part of the vector index.\n- **Post-filtering:**\n  For all remaining filters, add a $match stage after $vectorSearch.\n- If unsure which fields are filterable, use the collection-indexes tool to determine valid prefilter fields.\n- If no requested filters are valid prefilters, omit the filter key from $vectorSearch.\n\n### Usage Rules for `$search`\n- Include the index name, unless you know for a fact there's a default index. If unsure, use the collection-indexes tool to determine the index name.\n- The `$search` stage supports multiple operators, such as 'autocomplete', 'text', 'geoWithin', and others. Choose the appropriate operator based on the user's query. If unsure of the exact syntax, consult the MongoDB Atlas Search documentation, which can be found here: https://www.mongodb.com/docs/atlas/atlas-search/operators-and-collectors/\n\n### Usage Rules for `$rankFusion` and `$scoreFusion` (Hybrid Search)\nUse these stages when the user wants to combine full-text (`$search`) and vector\n(`$vectorSearch`) retrieval into a single fused result set. **Prefer native\nfusion over a `$unionWith` + `$group` workaround** — the workaround averages\nincompatible score scales and produces wrong rankings.\n\n**Which stage to use:**\n- `$rankFusion` (MongoDB 8.0+) — Reciprocal Rank Fusion. The recommended default.\n  Normalizes scores across incompatible scales automatically. No score tuning needed.\n- `$scoreFusion` (MongoDB 8.2+) — Score-based fusion. Use when the user needs explicit\n  per-pipeline weights, score normalisation (sigmoid / minMaxScaler), or a custom\n  combination expression.\n\n**Construction rules:**\n- `$rankFusion` / `$scoreFusion` MUST be the first stage of the top-level pipeline.\n- Sub-pipelines go inside `input.pipelines` as a named map (not an array). Each name\n  must be non-empty, must not start with `$`, and must not contain `.` or null bytes.\n- Allowed stages inside sub-pipelines: `$search`, `$vectorSearch`, `$match`, `$sort`,\n  `$geoNear`, `$skip`, `$limit`. `$project` and `$unset` are NOT allowed inside sub-pipelines.\n- Do field shaping (`$project` / `$unset`) only AFTER the fusion stage, at the root.\n- Both a vectorSearch (or autoEmbed) index AND a search (lexical) index must exist on\n  the collection. Use the collection-indexes tool to confirm both before running a hybrid query.\n- Add a `$limit` stage after the fusion stage to cap the final result set.\n- Add `$unset` at the end to remove embedding fields and avoid context bloat.\n\n### Usage Rules for `$rerank` (Native Reranking)\nUse this stage when the user wants to reorder a set of candidate documents using a cross-encoder reranker model.\n\n**Construction rules:**\n- `$rerank` can be any stage in the pipeline on an Atlas cluster running MongoDB 8.3 or higher.\n- It is recommended to use `$rerank` after a sorted pipeline, e.g. `$search`, `$vectorSearch`, `$rankFusion`, `$scoreFusion`, or [`$match`, `$sort`].\n- $rerank must be enabled via the Native Reranking Project Setting\n- Set `numDocsToRerank` as the number of documents passed into `$rerank`. This will also limit the number of documents returned by `$rerank`\n- Set `path` as a field name or an array of field names that exist in all documents. Use `$match` or `$set` before `$rerank` to validate no fields are missing.\n- Add `$addFields` after `$rerank` to retrieve the reranker score.\n\n**`$rerank` example (recommended default):**\n```javascript\n[\n  {\n    $match: {\n      description: { $exists: true },\n      name: { $exists: true }\n    }\n  },\n  {\n    $sort: {\n      lastUpdated: -1\n    }\n  },\n  {\n    $rerank: {\n      query: {\n        text: \"query text including instructions\"\n      },\n      model: \"rerank-2.5\",\n      numDocsToRerank: 100,\n      path: [\"description\", \"name\"]\n    }\n  },\n  {\n    $addFields: {\n      rerankScore: { $meta: \"score\" }\n    }\n  }\n]\n```\n",
                              "items": {
                                "anyOf": [
                                  {
                                    "properties": {
                                      "$vectorSearch": {
                                        "anyOf": [
                                          {
                                            "description": "Classic vector search using 'queryVector'. Use this when the indexed field has a classic vector index (type: 'vector'). Note to LLM: Use the collection-indexes tool to verify the target field has a classic vector index before using 'queryVector'.",
                                            "properties": {
                                              "exact": {
                                                "default": false,
                                                "description": "When true, uses an ENN algorithm, otherwise uses ANN. Using ENN is not compatible with numCandidates, in that case, numCandidates must be left empty.",
                                                "type": "boolean"
                                              },
                                              "filter": {
                                                "additionalProperties": {},
                                                "description": "MQL filter that can only use filter fields from the index definition. Note to LLM: If unsure, use the `collection-indexes` tool to learn which fields can be used for filtering.",
                                                "properties": {},
                                                "type": "object"
                                              },
                                              "index": {
                                                "description": "Name of the index, as retrieved from the `collection-indexes` tool.",
                                                "type": "string"
                                              },
                                              "limit": {
                                                "default": 10,
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "numCandidates": {
                                                "description": "Number of candidates for the ANN algorithm. Mandatory when exact is false.",
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "path": {
                                                "description": "Field, in dot notation, where to search. There must be a vector search index for that field.",
                                                "type": "string"
                                              },
                                              "queryVector": {
                                                "description": "The vector embeddings to search for when using classic vector search indexes (type: 'vector'). Provide embeddings as an array of numbers. Use this for classic vector indexes. For auto-embed indexes (type: 'autoEmbed'), use 'query' instead.",
                                                "items": {
                                                  "type": "number"
                                                },
                                                "type": "array"
                                              }
                                            },
                                            "required": [
                                              "index",
                                              "path",
                                              "queryVector"
                                            ],
                                            "type": "object"
                                          },
                                          {
                                            "description": "Auto-embed vector search using 'query'. Use this when the indexed field has an auto-embed index (type: 'autoEmbed'). Note to LLM: Use the collection-indexes tool to verify the target field has an auto-embed index before using 'query'.",
                                            "properties": {
                                              "exact": {
                                                "default": false,
                                                "description": "When true, uses an ENN algorithm, otherwise uses ANN. Using ENN is not compatible with numCandidates, in that case, numCandidates must be left empty.",
                                                "type": "boolean"
                                              },
                                              "filter": {
                                                "additionalProperties": {},
                                                "description": "MQL filter that can only use filter fields from the index definition. Note to LLM: If unsure, use the `collection-indexes` tool to learn which fields can be used for filtering.",
                                                "properties": {},
                                                "type": "object"
                                              },
                                              "index": {
                                                "description": "Name of the index, as retrieved from the `collection-indexes` tool.",
                                                "type": "string"
                                              },
                                              "limit": {
                                                "default": 10,
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "model": {
                                                "description": "The embedding model to use for generating embeddings from the query text. If not specified, defaults to the model configured in the auto-embed index definition.",
                                                "enum": [
                                                  "voyage-4",
                                                  "voyage-4-large",
                                                  "voyage-4-lite",
                                                  "voyage-code-3"
                                                ],
                                                "type": "string"
                                              },
                                              "numCandidates": {
                                                "description": "Number of candidates for the ANN algorithm. Mandatory when exact is false.",
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "path": {
                                                "description": "Field, in dot notation, where to search. There must be a vector search index for that field.",
                                                "type": "string"
                                              },
                                              "query": {
                                                "description": "The query to search for when using auto-embed indexes (type: 'autoEmbed'). MongoDB will automatically generate embeddings for the text at query time. Use this for auto-embed indexes, not 'queryVector'.",
                                                "properties": {
                                                  "text": {
                                                    "description": "The text query to search for.",
                                                    "type": "string"
                                                  }
                                                },
                                                "required": [
                                                  "text"
                                                ],
                                                "type": "object"
                                              }
                                            },
                                            "required": [
                                              "index",
                                              "path",
                                              "query"
                                            ],
                                            "type": "object"
                                          }
                                        ]
                                      }
                                    },
                                    "required": [
                                      "$vectorSearch"
                                    ],
                                    "type": "object"
                                  },
                                  {
                                    "additionalProperties": {},
                                    "properties": {},
                                    "type": "object"
                                  }
                                ]
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "pipeline"
                          ],
                          "type": "object"
                        },
                        "name": {
                          "const": "aggregate",
                          "type": "string"
                        }
                      },
                      "required": [
                        "name",
                        "arguments"
                      ],
                      "type": "object"
                    },
                    {
                      "properties": {
                        "arguments": {
                          "properties": {
                            "filter": {
                              "additionalProperties": {},
                              "description": "The query filter, matching the syntax of the query argument of db.collection.find()",
                              "properties": {},
                              "type": "object"
                            },
                            "limit": {
                              "default": 10,
                              "description": "The maximum number of documents to return",
                              "type": "number"
                            },
                            "projection": {
                              "additionalProperties": {},
                              "description": "The projection, matching the syntax of the projection argument of db.collection.find()",
                              "properties": {},
                              "type": "object"
                            },
                            "sort": {
                              "additionalProperties": {
                                "anyOf": [
                                  {
                                    "const": 1,
                                    "type": "number"
                                  },
                                  {
                                    "const": -1,
                                    "type": "number"
                                  },
                                  {
                                    "const": "asc",
                                    "type": "string"
                                  },
                                  {
                                    "const": "desc",
                                    "type": "string"
                                  },
                                  {
                                    "const": "ascending",
                                    "type": "string"
                                  },
                                  {
                                    "const": "descending",
                                    "type": "string"
                                  },
                                  {
                                    "properties": {
                                      "$meta": {
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "$meta"
                                    ],
                                    "type": "object"
                                  }
                                ],
                                "description": "The sort key and its direction"
                              },
                              "description": "A document, describing the sort order, matching the syntax of the sort argument of cursor.sort(). The keys of the object are the fields to sort on, while the values are the sort directions (1 for ascending, -1 for descending).",
                              "propertyNames": {
                                "type": "string"
                              },
                              "type": "object"
                            }
                          },
                          "type": "object"
                        },
                        "name": {
                          "const": "find",
                          "type": "string"
                        }
                      },
                      "required": [
                        "name",
                        "arguments"
                      ],
                      "type": "object"
                    },
                    {
                      "properties": {
                        "arguments": {
                          "properties": {
                            "query": {
                              "additionalProperties": {},
                              "description": "A filter/query parameter. Allows users to filter the documents to count. Matches the syntax of the filter argument of db.collection.count().",
                              "properties": {},
                              "type": "object"
                            }
                          },
                          "type": "object"
                        },
                        "name": {
                          "const": "count",
                          "type": "string"
                        }
                      },
                      "required": [
                        "name",
                        "arguments"
                      ],
                      "type": "object"
                    }
                  ]
                },
                "type": "array"
              },
              "verbosity": {
                "default": "queryPlanner",
                "description": "The verbosity of the explain plan, defaults to queryPlanner. If the user wants to know how fast is a query in execution time, use executionStats. It supports all verbosities as defined in the MongoDB Driver.",
                "enum": [
                  "queryPlanner",
                  "queryPlannerExtended",
                  "executionStats",
                  "allPlansExecution"
                ],
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "method"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "explainResult": {
                "additionalProperties": {},
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              },
              "method": {
                "enum": [
                  "aggregate",
                  "find",
                  "count"
                ],
                "type": "string"
              },
              "verbosity": {
                "enum": [
                  "queryPlanner",
                  "queryPlannerExtended",
                  "executionStats",
                  "allPlansExecution"
                ],
                "type": "string"
              }
            },
            "required": [
              "explainResult",
              "method",
              "verbosity"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:b645f4dccb68cfbdc96940dddfca3373bf021cb9c9b4559a99ef2bbcca62eadd"
        },
        {
          "id": "mcp:MongoDB MCP Server/export",
          "name": "export",
          "title": "export",
          "description": "Export a query or aggregation results in the specified EJSON format.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "export"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "exportTarget": {
                "description": "The export target along with its arguments.",
                "items": {
                  "oneOf": [
                    {
                      "properties": {
                        "arguments": {
                          "description": "The arguments for 'find' operation.",
                          "properties": {
                            "filter": {
                              "additionalProperties": {},
                              "description": "The query filter, matching the syntax of the query argument of db.collection.find()",
                              "properties": {},
                              "type": "object"
                            },
                            "limit": {
                              "type": "number"
                            },
                            "projection": {
                              "additionalProperties": {},
                              "description": "The projection, matching the syntax of the projection argument of db.collection.find()",
                              "properties": {},
                              "type": "object"
                            },
                            "sort": {
                              "additionalProperties": {
                                "anyOf": [
                                  {
                                    "const": 1,
                                    "type": "number"
                                  },
                                  {
                                    "const": -1,
                                    "type": "number"
                                  },
                                  {
                                    "const": "asc",
                                    "type": "string"
                                  },
                                  {
                                    "const": "desc",
                                    "type": "string"
                                  },
                                  {
                                    "const": "ascending",
                                    "type": "string"
                                  },
                                  {
                                    "const": "descending",
                                    "type": "string"
                                  },
                                  {
                                    "properties": {
                                      "$meta": {
                                        "type": "string"
                                      }
                                    },
                                    "required": [
                                      "$meta"
                                    ],
                                    "type": "object"
                                  }
                                ],
                                "description": "The sort key and its direction"
                              },
                              "description": "A document, describing the sort order, matching the syntax of the sort argument of cursor.sort(). The keys of the object are the fields to sort on, while the values are the sort directions (1 for ascending, -1 for descending).",
                              "propertyNames": {
                                "type": "string"
                              },
                              "type": "object"
                            }
                          },
                          "type": "object"
                        },
                        "name": {
                          "const": "find",
                          "description": "The literal name 'find' to represent a find cursor as target.",
                          "type": "string"
                        }
                      },
                      "required": [
                        "name",
                        "arguments"
                      ],
                      "type": "object"
                    },
                    {
                      "properties": {
                        "arguments": {
                          "description": "The arguments for 'aggregate' operation.",
                          "properties": {
                            "pipeline": {
                              "description": "An array of aggregation stages to execute.\n\nIf the user has asked for a vector search, `$vectorSearch` **MUST** be the first stage\nof the pipeline (or the first stage of a `$unionWith` sub-pipeline only when explicitly\ncombining unrelated result sets — for hybrid full-text + vector search, use `$rankFusion`\nor `$scoreFusion` instead, see below).\n\nIf the user has asked for lexical/Atlas search, use `$search` instead of `$text`.\n### Usage Rules for `$vectorSearch`\n- **Index Type Detection:**\n  Use the collection-indexes tool to determine if the target field has a classic vector index (type: 'vector') or an auto-embed index (type: 'autoEmbed').\n- **Classic Vector Search (type: 'vector'):**\n  Use 'queryVector' with embeddings as an array of numbers.\n- **Auto-Embed Vector Search (type: 'autoEmbed'):**\n  Use 'query' - MongoDB automatically generates embeddings at query time. Do NOT use 'queryVector' or 'embeddingParameters' for auto-embed indexes.\n- **Unset embeddings:**\n  Unless the user explicitly requests the embeddings, add an `$unset` stage **at the end of the pipeline** to remove the embedding field and avoid context limits. **The $unset stage in this situation is mandatory**.\n- **Pre-filtering:**\n  If the user requests additional filtering, include filters in `$vectorSearch.filter` only for pre-filter fields in the vector index.\n  NEVER include fields in $vectorSearch.filter that are not part of the vector index.\n- **Post-filtering:**\n  For all remaining filters, add a $match stage after $vectorSearch.\n- If unsure which fields are filterable, use the collection-indexes tool to determine valid prefilter fields.\n- If no requested filters are valid prefilters, omit the filter key from $vectorSearch.\n\n### Usage Rules for `$search`\n- Include the index name, unless you know for a fact there's a default index. If unsure, use the collection-indexes tool to determine the index name.\n- The `$search` stage supports multiple operators, such as 'autocomplete', 'text', 'geoWithin', and others. Choose the appropriate operator based on the user's query. If unsure of the exact syntax, consult the MongoDB Atlas Search documentation, which can be found here: https://www.mongodb.com/docs/atlas/atlas-search/operators-and-collectors/\n\n### Usage Rules for `$rankFusion` and `$scoreFusion` (Hybrid Search)\nUse these stages when the user wants to combine full-text (`$search`) and vector\n(`$vectorSearch`) retrieval into a single fused result set. **Prefer native\nfusion over a `$unionWith` + `$group` workaround** — the workaround averages\nincompatible score scales and produces wrong rankings.\n\n**Which stage to use:**\n- `$rankFusion` (MongoDB 8.0+) — Reciprocal Rank Fusion. The recommended default.\n  Normalizes scores across incompatible scales automatically. No score tuning needed.\n- `$scoreFusion` (MongoDB 8.2+) — Score-based fusion. Use when the user needs explicit\n  per-pipeline weights, score normalisation (sigmoid / minMaxScaler), or a custom\n  combination expression.\n\n**Construction rules:**\n- `$rankFusion` / `$scoreFusion` MUST be the first stage of the top-level pipeline.\n- Sub-pipelines go inside `input.pipelines` as a named map (not an array). Each name\n  must be non-empty, must not start with `$`, and must not contain `.` or null bytes.\n- Allowed stages inside sub-pipelines: `$search`, `$vectorSearch`, `$match`, `$sort`,\n  `$geoNear`, `$skip`, `$limit`. `$project` and `$unset` are NOT allowed inside sub-pipelines.\n- Do field shaping (`$project` / `$unset`) only AFTER the fusion stage, at the root.\n- Both a vectorSearch (or autoEmbed) index AND a search (lexical) index must exist on\n  the collection. Use the collection-indexes tool to confirm both before running a hybrid query.\n- Add a `$limit` stage after the fusion stage to cap the final result set.\n- Add `$unset` at the end to remove embedding fields and avoid context bloat.\n\n### Usage Rules for `$rerank` (Native Reranking)\nUse this stage when the user wants to reorder a set of candidate documents using a cross-encoder reranker model.\n\n**Construction rules:**\n- `$rerank` can be any stage in the pipeline on an Atlas cluster running MongoDB 8.3 or higher.\n- It is recommended to use `$rerank` after a sorted pipeline, e.g. `$search`, `$vectorSearch`, `$rankFusion`, `$scoreFusion`, or [`$match`, `$sort`].\n- $rerank must be enabled via the Native Reranking Project Setting\n- Set `numDocsToRerank` as the number of documents passed into `$rerank`. This will also limit the number of documents returned by `$rerank`\n- Set `path` as a field name or an array of field names that exist in all documents. Use `$match` or `$set` before `$rerank` to validate no fields are missing.\n- Add `$addFields` after `$rerank` to retrieve the reranker score.\n\n**`$rerank` example (recommended default):**\n```javascript\n[\n  {\n    $match: {\n      description: { $exists: true },\n      name: { $exists: true }\n    }\n  },\n  {\n    $sort: {\n      lastUpdated: -1\n    }\n  },\n  {\n    $rerank: {\n      query: {\n        text: \"query text including instructions\"\n      },\n      model: \"rerank-2.5\",\n      numDocsToRerank: 100,\n      path: [\"description\", \"name\"]\n    }\n  },\n  {\n    $addFields: {\n      rerankScore: { $meta: \"score\" }\n    }\n  }\n]\n```\n",
                              "items": {
                                "anyOf": [
                                  {
                                    "properties": {
                                      "$vectorSearch": {
                                        "anyOf": [
                                          {
                                            "description": "Classic vector search using 'queryVector'. Use this when the indexed field has a classic vector index (type: 'vector'). Note to LLM: Use the collection-indexes tool to verify the target field has a classic vector index before using 'queryVector'.",
                                            "properties": {
                                              "exact": {
                                                "default": false,
                                                "description": "When true, uses an ENN algorithm, otherwise uses ANN. Using ENN is not compatible with numCandidates, in that case, numCandidates must be left empty.",
                                                "type": "boolean"
                                              },
                                              "filter": {
                                                "additionalProperties": {},
                                                "description": "MQL filter that can only use filter fields from the index definition. Note to LLM: If unsure, use the `collection-indexes` tool to learn which fields can be used for filtering.",
                                                "properties": {},
                                                "type": "object"
                                              },
                                              "index": {
                                                "description": "Name of the index, as retrieved from the `collection-indexes` tool.",
                                                "type": "string"
                                              },
                                              "limit": {
                                                "default": 10,
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "numCandidates": {
                                                "description": "Number of candidates for the ANN algorithm. Mandatory when exact is false.",
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "path": {
                                                "description": "Field, in dot notation, where to search. There must be a vector search index for that field.",
                                                "type": "string"
                                              },
                                              "queryVector": {
                                                "description": "The vector embeddings to search for when using classic vector search indexes (type: 'vector'). Provide embeddings as an array of numbers. Use this for classic vector indexes. For auto-embed indexes (type: 'autoEmbed'), use 'query' instead.",
                                                "items": {
                                                  "type": "number"
                                                },
                                                "type": "array"
                                              }
                                            },
                                            "required": [
                                              "index",
                                              "path",
                                              "queryVector"
                                            ],
                                            "type": "object"
                                          },
                                          {
                                            "description": "Auto-embed vector search using 'query'. Use this when the indexed field has an auto-embed index (type: 'autoEmbed'). Note to LLM: Use the collection-indexes tool to verify the target field has an auto-embed index before using 'query'.",
                                            "properties": {
                                              "exact": {
                                                "default": false,
                                                "description": "When true, uses an ENN algorithm, otherwise uses ANN. Using ENN is not compatible with numCandidates, in that case, numCandidates must be left empty.",
                                                "type": "boolean"
                                              },
                                              "filter": {
                                                "additionalProperties": {},
                                                "description": "MQL filter that can only use filter fields from the index definition. Note to LLM: If unsure, use the `collection-indexes` tool to learn which fields can be used for filtering.",
                                                "properties": {},
                                                "type": "object"
                                              },
                                              "index": {
                                                "description": "Name of the index, as retrieved from the `collection-indexes` tool.",
                                                "type": "string"
                                              },
                                              "limit": {
                                                "default": 10,
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "model": {
                                                "description": "The embedding model to use for generating embeddings from the query text. If not specified, defaults to the model configured in the auto-embed index definition.",
                                                "enum": [
                                                  "voyage-4",
                                                  "voyage-4-large",
                                                  "voyage-4-lite",
                                                  "voyage-code-3"
                                                ],
                                                "type": "string"
                                              },
                                              "numCandidates": {
                                                "description": "Number of candidates for the ANN algorithm. Mandatory when exact is false.",
                                                "exclusiveMinimum": 0,
                                                "maximum": 9007199254740991,
                                                "type": "integer"
                                              },
                                              "path": {
                                                "description": "Field, in dot notation, where to search. There must be a vector search index for that field.",
                                                "type": "string"
                                              },
                                              "query": {
                                                "description": "The query to search for when using auto-embed indexes (type: 'autoEmbed'). MongoDB will automatically generate embeddings for the text at query time. Use this for auto-embed indexes, not 'queryVector'.",
                                                "properties": {
                                                  "text": {
                                                    "description": "The text query to search for.",
                                                    "type": "string"
                                                  }
                                                },
                                                "required": [
                                                  "text"
                                                ],
                                                "type": "object"
                                              }
                                            },
                                            "required": [
                                              "index",
                                              "path",
                                              "query"
                                            ],
                                            "type": "object"
                                          }
                                        ]
                                      }
                                    },
                                    "required": [
                                      "$vectorSearch"
                                    ],
                                    "type": "object"
                                  },
                                  {
                                    "additionalProperties": {},
                                    "properties": {},
                                    "type": "object"
                                  }
                                ]
                              },
                              "type": "array"
                            }
                          },
                          "required": [
                            "pipeline"
                          ],
                          "type": "object"
                        },
                        "name": {
                          "const": "aggregate",
                          "description": "The literal name 'aggregate' to represent an aggregation cursor as target.",
                          "type": "string"
                        }
                      },
                      "required": [
                        "name",
                        "arguments"
                      ],
                      "type": "object"
                    }
                  ]
                },
                "type": "array"
              },
              "exportTitle": {
                "description": "A short description to uniquely identify the export.",
                "type": "string"
              },
              "jsonExportFormat": {
                "default": "relaxed",
                "description": "The format to be used when exporting collection data as EJSON with default being relaxed.\nrelaxed: A string format that emphasizes readability and interoperability at the expense of type preservation. That is, conversion from relaxed format to BSON can lose type information.\ncanonical: A string format that emphasizes type preservation at the expense of readability and interoperability. That is, conversion from canonical to BSON will generally preserve type information except in certain specific cases.",
                "enum": [
                  "relaxed",
                  "canonical"
                ],
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "exportTitle",
              "exportTarget"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:723a9def47e02505f32a19c1438f70bf4e9f21569a961dd00f4cd0d370635eaf"
        },
        {
          "id": "mcp:MongoDB MCP Server/find",
          "name": "find",
          "title": "find",
          "description": "Run a find query against a MongoDB collection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "find"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "filter": {
                "additionalProperties": {},
                "description": "The query filter, matching the syntax of the query argument of db.collection.find()",
                "properties": {},
                "type": "object"
              },
              "limit": {
                "default": 10,
                "description": "The maximum number of documents to return",
                "type": "number"
              },
              "projection": {
                "additionalProperties": {},
                "description": "The projection, matching the syntax of the projection argument of db.collection.find()",
                "properties": {},
                "type": "object"
              },
              "responseBytesLimit": {
                "default": 1048576,
                "description": "The maximum number of bytes to return in the response. This value is capped by the server's configured maximum and cannot be exceeded.",
                "type": "number"
              },
              "sort": {
                "additionalProperties": {
                  "anyOf": [
                    {
                      "const": 1,
                      "type": "number"
                    },
                    {
                      "const": -1,
                      "type": "number"
                    },
                    {
                      "const": "asc",
                      "type": "string"
                    },
                    {
                      "const": "desc",
                      "type": "string"
                    },
                    {
                      "const": "ascending",
                      "type": "string"
                    },
                    {
                      "const": "descending",
                      "type": "string"
                    },
                    {
                      "properties": {
                        "$meta": {
                          "type": "string"
                        }
                      },
                      "required": [
                        "$meta"
                      ],
                      "type": "object"
                    }
                  ],
                  "description": "The sort key and its direction"
                },
                "description": "A document, describing the sort order, matching the syntax of the sort argument of cursor.sort(). The keys of the object are the fields to sort on, while the values are the sort directions (1 for ascending, -1 for descending).",
                "propertyNames": {
                  "type": "string"
                },
                "type": "object"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "appliedLimits": {
                "description": "The limits applied to the find query",
                "items": {
                  "enum": [
                    "config.maxDocumentsPerQuery",
                    "config.maxBytesPerQuery",
                    "tool.responseBytesLimit"
                  ],
                  "type": "string"
                },
                "type": "array"
              },
              "documents": {
                "description": "The documents returned by the find query",
                "items": {},
                "type": "array"
              },
              "queryResultsCount": {
                "description": "The total number of documents returned by the find query",
                "type": "number"
              }
            },
            "required": [
              "documents",
              "appliedLimits"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:98064d39a5f64a91856cb5360eeeffb4b22430ffd71aa1550aa8f2daee84a649"
        },
        {
          "id": "mcp:MongoDB MCP Server/insert-many",
          "name": "insert-many",
          "title": "insert-many",
          "description": "Insert an array of documents into a MongoDB collection. If the list of documents is above com.mongodb/maxRequestPayloadBytes, consider inserting them in batches.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "insert-many"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "documents": {
                "description": "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany().",
                "items": {
                  "additionalProperties": {},
                  "description": "An individual MongoDB document",
                  "properties": {},
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "documents"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "type": "string"
              },
              "database": {
                "type": "string"
              },
              "insertedCount": {
                "type": "number"
              },
              "insertedIds": {
                "items": {},
                "type": "array"
              }
            },
            "required": [
              "database",
              "collection",
              "insertedCount",
              "insertedIds"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:0279d3fa2b8996231059855b577d14d14e6d3888f1d95169fddccd310bdb88d2"
        },
        {
          "id": "mcp:MongoDB MCP Server/list-collections",
          "name": "list-collections",
          "title": "list-collections",
          "description": "List all collections for a given database",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "list-collections"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collections": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "name": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "name"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "totalCount": {
                "type": "number"
              }
            },
            "required": [
              "collections",
              "totalCount"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:8f64261ef8fbdbc97b5df98e91e0235bc97911541dad9db45410ef251854a5a5"
        },
        {
          "id": "mcp:MongoDB MCP Server/list-connections",
          "name": "list-connections",
          "title": "list-connections",
          "description": "List the active MongoDB connections and their connectionIds. Use this to find a connectionId established earlier.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "list-connections"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {},
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connections": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "connectionId": {
                      "type": "string"
                    },
                    "createdAt": {
                      "type": "string"
                    },
                    "description": {
                      "type": "string"
                    },
                    "lastError": {
                      "type": "string"
                    },
                    "lastUsedAt": {
                      "type": "string"
                    },
                    "name": {
                      "type": "string"
                    },
                    "source": {
                      "enum": [
                        "explicit",
                        "preconfigured"
                      ],
                      "type": "string"
                    },
                    "state": {
                      "enum": [
                        "connected",
                        "connecting",
                        "disconnected",
                        "errored"
                      ],
                      "type": "string"
                    }
                  },
                  "required": [
                    "connectionId",
                    "name",
                    "source",
                    "description",
                    "createdAt",
                    "lastUsedAt"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "connections"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:5dd7aa3b4c24875f6ba667d4c676da9319d894d6c0f8f1b2004043db09664ca2"
        },
        {
          "id": "mcp:MongoDB MCP Server/list-databases",
          "name": "list-databases",
          "title": "list-databases",
          "description": "List all databases for a MongoDB connection",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "list-databases"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              }
            },
            "required": [
              "connectionId"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "databases": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "name": {
                      "type": "string"
                    },
                    "size": {
                      "type": "number"
                    }
                  },
                  "required": [
                    "name",
                    "size"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "totalCount": {
                "type": "number"
              }
            },
            "required": [
              "databases",
              "totalCount"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:4e433949dee152e0f88e6bc4af2759f910ae65b74cd4f45a0e6aed857c765e5b"
        },
        {
          "id": "mcp:MongoDB MCP Server/list-knowledge-sources",
          "name": "list-knowledge-sources",
          "title": "list-knowledge-sources",
          "description": "List available data sources in the MongoDB Assistant knowledge base. Use this to explore available data sources or to find search filter parameters to use in search-knowledge.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "list-knowledge-sources"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {},
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:4440136b39fa99a5375cadd13d37d9fda5ec9a2e0cdab8f456a22abcd44cbf74"
        },
        {
          "id": "mcp:MongoDB MCP Server/mongodb-logs",
          "name": "mongodb-logs",
          "title": "mongodb-logs",
          "description": "Returns the most recent logged mongod events",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "mongodb-logs"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "limit": {
                "default": 50,
                "description": "The maximum number of log entries to return.",
                "maximum": 1024,
                "minimum": 1,
                "type": "integer"
              },
              "type": {
                "default": "global",
                "description": "The type of logs to return. Global returns all recent log entries, while startupWarnings returns only warnings and errors from when the process started.",
                "enum": [
                  "global",
                  "startupWarnings"
                ],
                "type": "string"
              }
            },
            "required": [
              "connectionId"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "logs": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "shownCount": {
                "type": "number"
              },
              "totalLinesWritten": {
                "type": "number"
              }
            },
            "required": [
              "logs",
              "totalLinesWritten",
              "shownCount"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:29a126d6367881ed4a5be6e5d0e5e98980cdbdebbb8990c609474fdd7afe0874"
        },
        {
          "id": "mcp:MongoDB MCP Server/rename-collection",
          "name": "rename-collection",
          "title": "rename-collection",
          "description": "Renames a collection in a MongoDB database",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "rename-collection"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "dropTarget": {
                "default": false,
                "description": "If true, drops the target collection if it exists",
                "type": "boolean"
              },
              "newName": {
                "description": "The new name for the collection",
                "type": "string"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "newName"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "database": {
                "type": "string"
              },
              "newCollection": {
                "type": "string"
              },
              "oldCollection": {
                "type": "string"
              },
              "renamed": {
                "type": "boolean"
              }
            },
            "required": [
              "database",
              "oldCollection",
              "newCollection",
              "renamed"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:366945f0c42bf0140a6fd3b86f9dcf3254ffde6689cfde860c42937f15de4bd3"
        },
        {
          "id": "mcp:MongoDB MCP Server/search-knowledge",
          "name": "search-knowledge",
          "title": "search-knowledge",
          "description": "Search for information in the MongoDB Assistant knowledge base. This includes official documentation, curated expert guidance, and other resources provided by MongoDB. Supports filtering by data source and version.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "search-knowledge"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "dataSources": {
                "description": "A list of one or more data sources to limit the search to. You can specify a specific version of a data source by providing the version label. If not provided, the latest version of all data sources will be searched. Available data sources and their versions can be listed by calling the list-knowledge-sources tool.",
                "items": {
                  "properties": {
                    "name": {
                      "description": "The name of the data source",
                      "type": "string"
                    },
                    "versionLabel": {
                      "description": "The version label of the data source",
                      "type": "string"
                    }
                  },
                  "required": [
                    "name"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "limit": {
                "default": 5,
                "description": "The maximum number of results to return",
                "maximum": 100,
                "minimum": 1,
                "type": "number"
              },
              "query": {
                "description": "A natural language query to search for in the MongoDB Assistant knowledge base. This should be a single question or a topic that is relevant to the user's MongoDB use case.",
                "type": "string"
              }
            },
            "required": [
              "query"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "true"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:65dccb54e10fd6f4cef3f036391fe81204f000d48b432833bb7cde1ce4fcd4fd"
        },
        {
          "id": "mcp:MongoDB MCP Server/update-many",
          "name": "update-many",
          "title": "update-many",
          "description": "Updates all documents that match the specified filter for a collection. If the list of documents is above com.mongodb/maxRequestPayloadBytes, consider updating them in batches.",
          "source": {
            "type": "mcp",
            "server": "MongoDB MCP Server",
            "operation": "update-many"
          },
          "input_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "description": "Collection name",
                "type": "string"
              },
              "connectionId": {
                "description": "The connection to run the operation against. Use the id returned by one of the connect tools.",
                "type": "string"
              },
              "database": {
                "description": "Database name",
                "type": "string"
              },
              "filter": {
                "additionalProperties": {},
                "description": "The selection criteria for the update, matching the syntax of the filter argument of db.collection.updateOne()",
                "properties": {},
                "type": "object"
              },
              "update": {
                "additionalProperties": {},
                "description": "An update document describing the modifications to apply using update operator expressions",
                "properties": {},
                "type": "object"
              },
              "upsert": {
                "description": "Controls whether to insert a new document if no documents match the filter",
                "type": "boolean"
              }
            },
            "required": [
              "connectionId",
              "database",
              "collection",
              "update"
            ],
            "type": "object"
          },
          "output_schema": {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "additionalProperties": false,
            "properties": {
              "collection": {
                "type": "string"
              },
              "database": {
                "type": "string"
              },
              "matchedCount": {
                "type": "number"
              },
              "modifiedCount": {
                "type": "number"
              },
              "upsertedCount": {
                "type": "number"
              },
              "upsertedId": {
                "type": "string"
              }
            },
            "required": [
              "database",
              "collection",
              "matchedCount",
              "modifiedCount",
              "upsertedCount"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "true",
            "idempotent": "false",
            "open_world": "true"
          },
          "effects": {
            "kind": "write",
            "destructive": "true",
            "external": "true"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "destructive",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:00b1095940e8e65aa065cf2bb72ce31278bf4a1fde190e23a6b4f312c390dca7"
        }
      ],
      "discovery_order": [
        "mcp:MongoDB MCP Server/aggregate-db",
        "mcp:MongoDB MCP Server/aggregate",
        "mcp:MongoDB MCP Server/collection-indexes",
        "mcp:MongoDB MCP Server/collection-schema",
        "mcp:MongoDB MCP Server/collection-storage-size",
        "mcp:MongoDB MCP Server/connect",
        "mcp:MongoDB MCP Server/count",
        "mcp:MongoDB MCP Server/create-collection",
        "mcp:MongoDB MCP Server/create-index",
        "mcp:MongoDB MCP Server/db-stats",
        "mcp:MongoDB MCP Server/delete-many",
        "mcp:MongoDB MCP Server/disconnect",
        "mcp:MongoDB MCP Server/drop-collection",
        "mcp:MongoDB MCP Server/drop-database",
        "mcp:MongoDB MCP Server/drop-index",
        "mcp:MongoDB MCP Server/explain",
        "mcp:MongoDB MCP Server/export",
        "mcp:MongoDB MCP Server/find",
        "mcp:MongoDB MCP Server/insert-many",
        "mcp:MongoDB MCP Server/list-collections",
        "mcp:MongoDB MCP Server/list-connections",
        "mcp:MongoDB MCP Server/list-databases",
        "mcp:MongoDB MCP Server/mongodb-logs",
        "mcp:MongoDB MCP Server/rename-collection",
        "mcp:MongoDB MCP Server/update-many",
        "mcp:MongoDB MCP Server/search-knowledge",
        "mcp:MongoDB MCP Server/list-knowledge-sources"
      ],
      "fingerprint": "sha256:b8303b74545bc0f8b3812e41a8a1ed5351fd438d273bc3fcbde42f594cd33d19"
    },
    "summary": {
      "total": 27,
      "read_only": 18,
      "potential_writes": 9,
      "destructive": 6,
      "unknown_effects": 0,
      "retry_safe": 18
    },
    "schema_stats": {
      "mcp:MongoDB MCP Server/aggregate": {
        "input": {
          "properties": 5,
          "required": 4,
          "total_properties": 22,
          "nested_objects": 7,
          "arrays": 2,
          "max_depth": 4,
          "combinators": 4,
          "refs": 0,
          "complexity": 35
        },
        "output": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 2,
          "max_depth": 1,
          "combinators": 2,
          "refs": 0,
          "complexity": 7
        }
      },
      "mcp:MongoDB MCP Server/aggregate-db": {
        "input": {
          "properties": 4,
          "required": 3,
          "total_properties": 4,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        },
        "output": {
          "properties": 3,
          "required": 2,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 2,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:MongoDB MCP Server/collection-indexes": {
        "input": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        },
        "output": {
          "properties": 4,
          "required": 4,
          "total_properties": 11,
          "nested_objects": 4,
          "arrays": 2,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 17
        }
      },
      "mcp:MongoDB MCP Server/collection-schema": {
        "input": {
          "properties": 5,
          "required": 3,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        },
        "output": {
          "properties": 2,
          "required": 2,
          "total_properties": 2,
          "nested_objects": 1,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:MongoDB MCP Server/collection-storage-size": {
        "input": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        },
        "output": {
          "properties": 2,
          "required": 2,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:MongoDB MCP Server/connect": {
        "input": {
          "properties": 2,
          "required": 1,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        },
        "output": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        }
      },
      "mcp:MongoDB MCP Server/count": {
        "input": {
          "properties": 4,
          "required": 3,
          "total_properties": 4,
          "nested_objects": 1,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        },
        "output": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        }
      },
      "mcp:MongoDB MCP Server/create-collection": {
        "input": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        },
        "output": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:MongoDB MCP Server/create-index": {
        "input": {
          "properties": 5,
          "required": 4,
          "total_properties": 27,
          "nested_objects": 10,
          "arrays": 2,
          "max_depth": 4,
          "combinators": 18,
          "refs": 0,
          "complexity": 57
        },
        "output": {
          "properties": 4,
          "required": 4,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:MongoDB MCP Server/db-stats": {
        "input": {
          "properties": 2,
          "required": 2,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        },
        "output": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 1,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:MongoDB MCP Server/delete-many": {
        "input": {
          "properties": 4,
          "required": 3,
          "total_properties": 4,
          "nested_objects": 1,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        },
        "output": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:MongoDB MCP Server/disconnect": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        },
        "output": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        }
      },
      "mcp:MongoDB MCP Server/drop-collection": {
        "input": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        },
        "output": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:MongoDB MCP Server/drop-database": {
        "input": {
          "properties": 2,
          "required": 2,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        },
        "output": {
          "properties": 2,
          "required": 2,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        }
      },
      "mcp:MongoDB MCP Server/drop-index": {
        "input": {
          "properties": 5,
          "required": 5,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        },
        "output": {
          "properties": 4,
          "required": 4,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:MongoDB MCP Server/explain": {
        "input": {
          "properties": 5,
          "required": 4,
          "total_properties": 35,
          "nested_objects": 18,
          "arrays": 3,
          "max_depth": 6,
          "combinators": 14,
          "refs": 0,
          "complexity": 70
        },
        "output": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 1,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:MongoDB MCP Server/export": {
        "input": {
          "properties": 6,
          "required": 5,
          "total_properties": 33,
          "nested_objects": 15,
          "arrays": 3,
          "max_depth": 6,
          "combinators": 13,
          "refs": 0,
          "complexity": 64
        }
      },
      "mcp:MongoDB MCP Server/find": {
        "input": {
          "properties": 8,
          "required": 3,
          "total_properties": 9,
          "nested_objects": 4,
          "arrays": 0,
          "max_depth": 2,
          "combinators": 7,
          "refs": 0,
          "complexity": 20
        },
        "output": {
          "properties": 3,
          "required": 2,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 2,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:MongoDB MCP Server/insert-many": {
        "input": {
          "properties": 4,
          "required": 4,
          "total_properties": 4,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        },
        "output": {
          "properties": 4,
          "required": 4,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:MongoDB MCP Server/list-collections": {
        "input": {
          "properties": 2,
          "required": 2,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        },
        "output": {
          "properties": 2,
          "required": 2,
          "total_properties": 3,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        }
      },
      "mcp:MongoDB MCP Server/list-connections": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        },
        "output": {
          "properties": 1,
          "required": 1,
          "total_properties": 9,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 11
        }
      },
      "mcp:MongoDB MCP Server/list-databases": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        },
        "output": {
          "properties": 2,
          "required": 2,
          "total_properties": 4,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:MongoDB MCP Server/list-knowledge-sources": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        }
      },
      "mcp:MongoDB MCP Server/mongodb-logs": {
        "input": {
          "properties": 3,
          "required": 1,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        },
        "output": {
          "properties": 3,
          "required": 3,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:MongoDB MCP Server/rename-collection": {
        "input": {
          "properties": 5,
          "required": 4,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 5
        },
        "output": {
          "properties": 4,
          "required": 4,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        }
      },
      "mcp:MongoDB MCP Server/search-knowledge": {
        "input": {
          "properties": 3,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 7
        }
      },
      "mcp:MongoDB MCP Server/update-many": {
        "input": {
          "properties": 6,
          "required": 4,
          "total_properties": 6,
          "nested_objects": 2,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 8
        },
        "output": {
          "properties": 6,
          "required": 5,
          "total_properties": 6,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      }
    }
  },
  "source": {
    "registry": "oci",
    "package": "docker.io/mongodb/mongodb-mcp-server",
    "version": "3.2.2",
    "upstream_version": "3.2.2",
    "published_at": "2026-11-05T01:15:52.69751Z",
    "integrity": "sha256-694ZH2ReAa09cGHudMvYJ+eZ7cjHbI9kEEhTMSrdvG0=",
    "artifact": "docker.io/mongodb/mongodb-mcp-server@sha256:ebde191f645e01ad3d7061ee74cbd827e799edc8c76c8f64104853312addbc6d",
    "repository": null
  },
  "analyzer": {
    "name": "modelara",
    "version": "v0.1.8",
    "policy_version": null
  },
  "capability_hash_version": 2,
  "capability_hashes": {
    "mongodb:tool:aggregate": {
      "description": "sha256:e95111c8aa91246addabc3ec15bf1f1fdea0aed6c59649b270c88c572c5e0d29",
      "input_schema": "sha256:99e4b137ebb9161d03ea9a93ce6ec93e3d722ba6101ef9e952aa42c25078cdf1",
      "output_schema": "sha256:efaa4109d480ac1dc1b3b8d7bc420a5b92fdd579ee931d3cb1c052b5276d5e18",
      "interface": "sha256:605131a16ffca250cab55106fe9186eea04cc21a6230a8d42d72b0caf6f65c61"
    },
    "mongodb:tool:aggregate-db": {
      "description": "sha256:2ac5d29a2d66f8f1e93b4abba74ae9431c613237b25bcdad9f30d13ae57aa31e",
      "input_schema": "sha256:95ab280081913b8124998befb12acc480a9ed1f45aa1e5a7afe2ee8ba1ca6f4a",
      "output_schema": "sha256:9cb347cf3f6a8517d6246ac6dd126e6af5b126b017ac05583cd8397fee3719b7",
      "interface": "sha256:ee0dc085ae4efe4ec8fcb57c90be0d8d7c40608cb55324fe0096a09d232c854b"
    },
    "mongodb:tool:collection-indexes": {
      "description": "sha256:9fc5f2b9148014103f89884f7cfd2805429ba3ba4df901237423efa05c74b9b1",
      "input_schema": "sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1",
      "output_schema": "sha256:8a88c2d2444e7e3517e0d6ea81cbbb73eb36996da61834c4dd53bca9c8924ccd",
      "interface": "sha256:9ef728a0ec842172183572973023dbf7d5fb363b9de567a1d3c21a69ccd49b80"
    },
    "mongodb:tool:collection-schema": {
      "description": "sha256:633e771fa6c89b3efc57e41ae825e23edb217d5ccadf5f0448d552e0d0c4b9f7",
      "input_schema": "sha256:6b8aad92ca32cb90acfd6968848f45f3388a31c9b6158815a3264f922d28d3ce",
      "output_schema": "sha256:61add100c0d48099262957a621136509eb5a08f37aa4d9d2bd0b9ed442252c3e",
      "interface": "sha256:223d71bf47078b300b958bcd84d145cb367a1cc4b5b554eb458b3ecb629d21eb"
    },
    "mongodb:tool:collection-storage-size": {
      "description": "sha256:4b4773a0b6f6d16c30236a05bb89b046153d188a08a4236c3c4cb3722f7f0c3e",
      "input_schema": "sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1",
      "output_schema": "sha256:1c2ee0b98a29881c6ba524a375a3fd668c0caea8aac090fffd1fd1f22542ab16",
      "interface": "sha256:5f04e8119732ed2681432205b12a883ae8dbc06200e28e01e54bf737d75f6b18"
    },
    "mongodb:tool:connect": {
      "description": "sha256:e5c36cf5838e982568db1ba806dd49dc3d946362b471856f840c8876c2c9f26e",
      "input_schema": "sha256:1f1a1e6f73be1fa35231786edf22d8d4703627f42abb7435afd5b5c5a5f188bb",
      "output_schema": "sha256:f6008b4d76c4d4e681ac85522677c154143083e27223f14412c89e9a0a39b7bd",
      "interface": "sha256:5cc0c0310fc2ad0fe1771625bac80aa8a825585bca78bb3ded8556b7addefb03"
    },
    "mongodb:tool:count": {
      "description": "sha256:8e4e6fa06555fc1081d384945a711870c7fae6f4747a42219856fe23fac2aebb",
      "input_schema": "sha256:1b3620093b2725f8f5cfac48e791845d674ce083b3612be0dac3024a455b922c",
      "output_schema": "sha256:a6f68e229471b00abd127b6a78c3a7aa04eeede740d2b95e3ae082c890f2c001",
      "interface": "sha256:624287a6b7dc2ddfd340e07bcc2f0433ed35af9ccb18509c50ea3941de7eced1"
    },
    "mongodb:tool:create-collection": {
      "description": "sha256:9b0a3c4ecb89315db83d039d6fee9c29912aa7584808f26ff4c66c4346e43ff0",
      "input_schema": "sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1",
      "output_schema": "sha256:e755bde3aff0b28557cbc055ee5bb9c5476d02b0a566b538cf92f2aa5dfec5d3",
      "interface": "sha256:c61b4211071397b0b826f7e27f40c7a23cfc7529680c016a58bc582426fc22df"
    },
    "mongodb:tool:create-index": {
      "description": "sha256:369b0ebfc4080c1caa7018a3867a3dd80da4d1f206ae843e5b4fdd7b53cb9ed3",
      "input_schema": "sha256:5b3aa07668ad34e1cab39e8edfcf619b08bd0acbe6c3b540f6754b3803be180a",
      "output_schema": "sha256:3ac38a3e2b18b83f340fe65fbe39ee7a11e5e0a116f4b8c06579baf7f9ac8a3b",
      "interface": "sha256:16b30f900bac8e3cf192d7d787139a854d130d06725f33344b4d90b2e8099f1b"
    },
    "mongodb:tool:db-stats": {
      "description": "sha256:7bd89dea5100f955ff8e7a0fb40a69172b202194049231f1516f1d01fb2647c3",
      "input_schema": "sha256:b592da734ad8ed633652a9a8c0e240cc7db738248a1f345e3bef2ce1a03afd49",
      "output_schema": "sha256:1f0781894e50d4aed74d1ac136cb7b930530055d41c1b9935b829da00c6c8097",
      "interface": "sha256:f4a46503c196bbd5035aa299e17d0781bbc6746c613143d1c3acdfff7a3f7cdd"
    },
    "mongodb:tool:delete-many": {
      "description": "sha256:8bc871a1d4faf83ea25eb8f8d8e7de96e0d5a3c97de454ff1bb8ec061c3e2828",
      "input_schema": "sha256:f4290cf4cc18ef3daf4151a71f9fdf1f5cb2dc75fb2ff51a1c03956ef35c24c3",
      "output_schema": "sha256:2aec887a846dde63b0fd024d6f3dacb9132eb05a2796577bd2b7ebacfdd6f4b3",
      "interface": "sha256:6ccd9d54b5f69cae6936a285dbd574f347ccc2dc7e3965944dc0658eb511eb71"
    },
    "mongodb:tool:disconnect": {
      "description": "sha256:82e3cf497a40709fb9a5bc839a3374aa6c30d6d315b1e619751efd44105f3f0a",
      "input_schema": "sha256:8b563a854f15a42ae24590b2cb05337603feefaec5dcc6bb4315a7d38e124920",
      "output_schema": "sha256:ada75b42100b27df8fdbaa5fa9ee614d4170bea5d85429c5bf2cb5ef33c91421",
      "interface": "sha256:a64ee0ee49cf285859c8b2d319400974a97b3121fc35f203755f0523efb30533"
    },
    "mongodb:tool:drop-collection": {
      "description": "sha256:82d48323402365f05bdc52033d5f6ef4e067a91aabd4230031934db830663220",
      "input_schema": "sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1",
      "output_schema": "sha256:fd6355220e7a07ffbd8e9610cf4118493e9b1c5332b96a0b3aeff600cd70471e",
      "interface": "sha256:2a28262918a6d38a419c689d9bb7e471c6cbec400d9b952fac2fb681d7746a3c"
    },
    "mongodb:tool:drop-database": {
      "description": "sha256:e8c980598c974215efe09df8f452a237cbf44c115a573e29ac37821a953ecefc",
      "input_schema": "sha256:b592da734ad8ed633652a9a8c0e240cc7db738248a1f345e3bef2ce1a03afd49",
      "output_schema": "sha256:02254a6d03963416de43488b9315f4aabae3ea2a7cd446422ab118a7a418357e",
      "interface": "sha256:adce02f1e7fc5486887bf8853d146e8ec6a32c096f4e47c334ad19ddecb6ddd1"
    },
    "mongodb:tool:drop-index": {
      "description": "sha256:6e190a387d527d2372b8aa106ecf6304f06a496fc4a7e683e40e68190226e25e",
      "input_schema": "sha256:15d356b9c5b42e091474cb2707509501b4979fa2efdc7edcc9ebfa2eefe118cb",
      "output_schema": "sha256:192012cd233b452a8957d4c75b481f33aeee45b013e7a2aa26ff87a7f6e45383",
      "interface": "sha256:273c455ddf1ae1eab3e60c81cea35677f2ac65af26c9425e8a2a599ea0b7c1e2"
    },
    "mongodb:tool:explain": {
      "description": "sha256:05536c415da1a5a1c915ddcfe62ac71810ecc5e97c7555b354dd83a5cce825a5",
      "input_schema": "sha256:7da19eaf79239a31d4d5eec9aafd5ef8ee8bcfd23f93eb5e7cce3fab9c2b51c1",
      "output_schema": "sha256:f9e0bf49b22a4e0cb053a12969d19adf177749471dbcd74971df05a76fde36c8",
      "interface": "sha256:39c6921001b97d66e210fb6ac8c3ad36112be0b22e24e60440e3d176bb9588b8"
    },
    "mongodb:tool:export": {
      "description": "sha256:c935603eea77da4889e6bc96828ed4f4227cda2b1c6b54138af4b470b94a229e",
      "input_schema": "sha256:0846929c68a9efa7ac77e2b700cc93e5d35fa398f93dbcdc08b7b58f3f9cf962",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:3f6dbd39d3a4a643b45a003ee8bdb1949198339caf363bef916b9abf20fa9d1d"
    },
    "mongodb:tool:find": {
      "description": "sha256:4849f28dfa27afe43b925c40ea9fd1ec03abe54e835f2059590741ff14e7b675",
      "input_schema": "sha256:6173a912fb60dd105f4a7034277e808ee90346690222d66d45c8f3b0f9e32b7c",
      "output_schema": "sha256:bdde12f60ac14d1cec6c08c306d6a83651fd55ffb1012bb06f3ad45f5d2ff2a1",
      "interface": "sha256:aba621b4ffc1a371b9e686726d6449a34f0c5aa1b162b0e1ba586e759a2fb483"
    },
    "mongodb:tool:insert-many": {
      "description": "sha256:3e9cea4927e028de1a30468cfb5d7300cdff594d8e492b22e8ed7c18921e4096",
      "input_schema": "sha256:00bd1a9056e8af2eeb36f55234494df440323ba8a2f6cfb65a4efc51649badea",
      "output_schema": "sha256:6b10473a4a31b81a87a67bf36a060ad4e1919e5b8d10659cc060cb393ad50f64",
      "interface": "sha256:474b37e0f1d08dacbdb600e1d844dc197302e7f8d1f877a5970b8c0a3da4b86d"
    },
    "mongodb:tool:list-collections": {
      "description": "sha256:2e3c57dc8202ce935fe90439023ad56b72b9cb33122b1354ad703f14ad338556",
      "input_schema": "sha256:b592da734ad8ed633652a9a8c0e240cc7db738248a1f345e3bef2ce1a03afd49",
      "output_schema": "sha256:b068515aed975bbf63b187e928862939a01ff844bb3e1232ebf2e4923d922578",
      "interface": "sha256:8355e849f75e0c75b346e2e847061fbad2a5808672e3515336f78f2a425a8cf0"
    },
    "mongodb:tool:list-connections": {
      "description": "sha256:b1c12814d4b720573bcfabf23eaa63b1520c24809b8a0c9bb1bda3522dccace0",
      "input_schema": "sha256:31b97051da0fdf608085f0fad34ff1d76e35fab98c3ccb7dec113918f20d2926",
      "output_schema": "sha256:05af6a3853be7bf1b8f627cf0cba63c9bd2c26d470d93b08af145688aefb8d96",
      "interface": "sha256:b2fe6a6ec852198b57524408e4f09f801f07782be788f65d20e639fe398b259e"
    },
    "mongodb:tool:list-databases": {
      "description": "sha256:9a317f31a393012e56a0dbed75ed02bff9a1d2de9cf8ff8c1bfdcae55c02db17",
      "input_schema": "sha256:c87338775ee2de7b02a6695303a8fd0c4a0f095db3de82bec40fb5772310ec63",
      "output_schema": "sha256:310ee01094fdb50cf678ad06ef5c65ac10d908c04514826467c27ebb457f89ef",
      "interface": "sha256:cac4d81ccef3cb7c892e651f3269fd3678c300ea2438e44f97512e947c3adb23"
    },
    "mongodb:tool:list-knowledge-sources": {
      "description": "sha256:b5eb2f8cbc8af05eb06f6f1899feb14ae5ecc92e4bba0a74865e5c64aa8a40eb",
      "input_schema": "sha256:31b97051da0fdf608085f0fad34ff1d76e35fab98c3ccb7dec113918f20d2926",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:fadf4896b8a48f826f2efb45b4e760447f3602d0310b97c9c25846ddff0542c5"
    },
    "mongodb:tool:mongodb-logs": {
      "description": "sha256:bdd7492085ec967c007ff5f76c1574d911b4e4ae240723e7358a4f6ac831cde5",
      "input_schema": "sha256:2ec118a6e69d45853f088572a68e1c3d91c8cfbcb6a60fa529d78e62deb6dfc3",
      "output_schema": "sha256:f15599b1dd30616225c4bbd598e2546e86aaeee556319227155c49f4e333f627",
      "interface": "sha256:9351a3cf4381055cedd486c799d68c9f3a5f3f55612b4620bf26166a6bdaf904"
    },
    "mongodb:tool:rename-collection": {
      "description": "sha256:2e18a7462fc8b4a8363bc5e2ebd215743ef600492db8acb4d0ab04681f10589c",
      "input_schema": "sha256:28978f50cf796cc2ebf7c7d45f059e855efcebcdcd6ffb5fc6bb625f1e7aa597",
      "output_schema": "sha256:8ac3064ab4884b553dd8b608f55339ce0e5893cccc2cafe677c261beb14af632",
      "interface": "sha256:cccd57417fcf11de8742d4d0b62869199db1e37eae9e88757e289b3ff7810122"
    },
    "mongodb:tool:search-knowledge": {
      "description": "sha256:5de2100b16b91cda71a93ebb750d2a18695beb9a5d1b95c8a92c961b8c4b36fb",
      "input_schema": "sha256:edc554120e1e050e2175d82d3cce156c678f6bad89c0fecb6881f74950c08794",
      "output_schema": "sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1",
      "interface": "sha256:476fba3173670ed53e751beb8939cb3f867c685567d5358b2e47b0941a813e59"
    },
    "mongodb:tool:update-many": {
      "description": "sha256:72fc7430afd06e6bf7445436a88fb66011a92d30f3179c722cbd4499e03a079b",
      "input_schema": "sha256:f66b405db3f2b693015b578bbbc3cac7bad7fc2be7ba155d24b4af46990923ed",
      "output_schema": "sha256:8efc76e8f1cfec10f411082fb8d9e84f8346b654827844dc6fb97687e812aa2f",
      "interface": "sha256:30e9a380c53ffa2c6b9b0af55b571aaa862a5c5bfd828b4566d87fc7a2d73970"
    }
  }
}
