Data MCP server

MongoDB MCP

Version history of discovered tools, schemas, and declared agent authority.

View watchlist

DistributionDistribution: OCI / Docker
Packagedocker.io/mongodb/mongodb-mcp-server
Latest analyzed version3.3.0
Current tool count27
Latest analysisNov 10, 2026
Package source

OBSERVED INTERFACE

Capability surface

Modelara’s observed declarations are shown separately from its derived effect classifications.

4 releases analyzed3.1.0 → 3.3.0Latest: 3.3.0
  • read18
  • write3
  • destructive6
  • unknown0

Unknown means Valyd could not determine the capability's effect confidently from the declared interface and static evidence. It is not treated as safe.

Package
docker.io/mongodb/mongodb-mcp-server@3.3.0
Registry
oci
Published
Nov 9, 2026
Integrity
sha256-UU+/dwOiQ2fwAcz1u51b5tX9ZM5XMpdRGDWqJYHEdMg=
Analyzer
modelara v0.1.8 · policy not recorded

27 capabilities

CapabilityTypeDerived effectFirst observed in Valyd coverageLast changed
aggregatemongodb:tool:aggregate
Observed interface and hashes

Run an aggregation against a MongoDB 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"
    },
    "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": true,
                        "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": true,
                        "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. Voyage-4 models share one embedding space: a cheaper Voyage-4 model can query any Voyage-4 index with no rebuild or re-embedding, though query tokens are still billed. Never mix families (e.g. voyage-code-3 on a Voyage-4 index). When explaining overrides, cover: the default (index model when omitted), shared space, family restriction, no rebuild, billing, and cost/latency vs relevance.",
                        "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": true,
            "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"
}
sha256:6e9c987d2cb08c1274f5f6e20cff8ac742bc04e1512dd50cbf5f3fc95f2e95d6

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",
      "type": "array"
    }
  },
  "required": [
    "documents",
    "count",
    "appliedLimits"
  ],
  "type": "object"
}
sha256:c88dc38c0dc5c1bedffe60b8cf9cebe8aa9be57060911f49456bc9ede46793f6

Description hash: sha256:e95111c8aa91246addabc3ec15bf1f1fdea0aed6c59649b270c88c572c5e0d29

Interface hash: sha256:85c59f57d91d0192be06f94099c86cf21906638d1f1b47faf0d83bc381fd5827

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/aggregate",
  "title": "aggregate",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "aggregate"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:91ffe51caaa2291967e348e4957a4cef317d99949275b03403b1027eb0057841"
}
toolread3.1.03.3.0
aggregate-dbmongodb:tool:aggregate-db
Observed interface and hashes

Run an aggregation against a MongoDB 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"
    },
    "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": true,
        "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"
}
sha256:775c0a7753122abea5e7652aee024e85edcd9d31b192b22f05cece6442745e33

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",
      "type": "array"
    }
  },
  "required": [
    "documents",
    "appliedLimits"
  ],
  "type": "object"
}
sha256:e9a5c487d0d1601d6e378f3a74ea0ecd0c11b74221c5ebc6ca9c725a1d69323d

Description hash: sha256:2ac5d29a2d66f8f1e93b4abba74ae9431c613237b25bcdad9f30d13ae57aa31e

Interface hash: sha256:109463f9a5414667184e0d4a6d082fb6e067a3198825959256163460ae892f87

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/aggregate-db",
  "title": "aggregate-db",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "aggregate-db"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:7f1b0443704a077169ec320b4d4de317e6d6f3e5a32227f50d10f9c319451dbd"
}
toolread3.1.03.3.0
collection-indexesmongodb:tool:collection-indexes
Observed interface and hashes

Describe the indexes for a 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"
}
sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1

Output schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "classicIndexes": {
      "items": {
        "additionalProperties": false,
        "properties": {
          "key": {
            "additionalProperties": true,
            "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": true,
            "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"
}
sha256:4546e0f7d23d12cad44d78abce4852a9bbcbd19c39ddfd12f4dce4d17702ce7a

Description hash: sha256:9fc5f2b9148014103f89884f7cfd2805429ba3ba4df901237423efa05c74b9b1

Interface hash: sha256:b40bc3153c69de831539cd1adde745a0beb3a1b8a47495afc0c6a7a4ce5ad27d

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/collection-indexes",
  "title": "collection-indexes",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "collection-indexes"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:d6e9ce19055a40508df2c0689c9fec4ceb3b3d1a7554582475808656bb2c56d8"
}
toolread3.1.03.3.0
collection-schemamongodb:tool:collection-schema
Observed interface and hashes

Describe the schema for a 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"
    },
    "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"
}
sha256:6b8aad92ca32cb90acfd6968848f45f3388a31c9b6158815a3264f922d28d3ce

Output schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "fieldsCount": {
      "type": "number"
    },
    "schema": {
      "additionalProperties": true,
      "propertyNames": {
        "type": "string"
      },
      "type": "object"
    }
  },
  "required": [
    "schema",
    "fieldsCount"
  ],
  "type": "object"
}
sha256:950c2ac42f0fec4124fc382904bf0c18037695c8247ef07f15c6964321762eb7

Description hash: sha256:633e771fa6c89b3efc57e41ae825e23edb217d5ccadf5f0448d552e0d0c4b9f7

Interface hash: sha256:d514a5324e46503849d8689312627bba92b2c0aa934acb2e82b3e7d52a091ead

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/collection-schema",
  "title": "collection-schema",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "collection-schema"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:f093626e51719b1b581633c3d05a67038e1d26fa777e6a63031de35e5fa0a8b2"
}
toolread3.1.03.3.0
collection-storage-sizemongodb:tool:collection-storage-size
Observed interface and hashes

Gets the size of the 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"
}
sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1

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"
}
sha256:1c2ee0b98a29881c6ba524a375a3fd668c0caea8aac090fffd1fd1f22542ab16

Description hash: sha256:4b4773a0b6f6d16c30236a05bb89b046153d188a08a4236c3c4cb3722f7f0c3e

Interface hash: sha256:5f04e8119732ed2681432205b12a883ae8dbc06200e28e01e54bf737d75f6b18

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/collection-storage-size",
  "title": "collection-storage-size",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "collection-storage-size"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:6e414e5fbb7eabd07fd2f0382471c3cf8cbd4ffc0c5bc7fea312c5e2916c75b3"
}
toolread3.1.0No change observed
connectmongodb:tool:connect
Observed interface and hashes

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.

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"
}
sha256:1f1a1e6f73be1fa35231786edf22d8d4703627f42abb7435afd5b5c5a5f188bb

Output schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "connectionId": {
      "type": "string"
    }
  },
  "required": [
    "connectionId"
  ],
  "type": "object"
}
sha256:f6008b4d76c4d4e681ac85522677c154143083e27223f14412c89e9a0a39b7bd

Description hash: sha256:e5c36cf5838e982568db1ba806dd49dc3d946362b471856f840c8876c2c9f26e

Interface hash: sha256:5cc0c0310fc2ad0fe1771625bac80aa8a825585bca78bb3ded8556b7addefb03

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/connect",
  "title": "connect",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "connect"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:cbd7d178714c5b850d3576b9bc45229bc27d7859a1048dc933754a7665b85ad4"
}
toolread3.1.0No change observed
countmongodb:tool:count
Observed interface and hashes

Gets the number of documents in a MongoDB collection using db.collection.count() and query as an optional filter parameter

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": true,
      "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"
}
sha256:0aa1d1b2f18f0e4386ff5084b2f6fa204c610522280de1f374c974df65ec1cdc

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"
}
sha256:a6f68e229471b00abd127b6a78c3a7aa04eeede740d2b95e3ae082c890f2c001

Description hash: sha256:8e4e6fa06555fc1081d384945a711870c7fae6f4747a42219856fe23fac2aebb

Interface hash: sha256:75eb6d68ddcdc6cda8a1efc50fc3b1a1a3ef8fc51fb74493d16a3917d9b85f32

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/count",
  "title": "count",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "count"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:6acee0fdaa7e10f29a1190b8cc85612eed31c9c9bd0241a69902349cb8e70ad6"
}
toolread3.1.03.3.0
create-collectionmongodb:tool:create-collection
Observed interface and hashes

Creates a new collection in a database. If the database doesn't exist, it will be created automatically.

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"
}
sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1

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"
}
sha256:e755bde3aff0b28557cbc055ee5bb9c5476d02b0a566b538cf92f2aa5dfec5d3

Description hash: sha256:9b0a3c4ecb89315db83d039d6fee9c29912aa7584808f26ff4c66c4346e43ff0

Interface hash: sha256:c61b4211071397b0b826f7e27f40c7a23cfc7529680c016a58bc582426fc22df

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/create-collection",
  "title": "create-collection",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "create-collection"
  },
  "declared": {
    "read_only": "false",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:745c06d8ae1715098c34198be9fcdb2b7368d5505264ff6271d086e3e91d88b2"
}
toolwrite3.1.0No change observed
create-indexmongodb:tool:create-index
Observed interface and hashes

Create an index for a 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"
    },
    "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. If the user asks only for semantic search without saying who produces the embeddings (MongoDB: 'autoEmbed'; they: 'vector'), don't create the index: explain both and ask. For keyword plus semantic (hybrid) setup, use 'autoEmbed' without asking.",
                "items": {
                  "oneOf": [
                    {
                      "additionalProperties": false,
                      "description": "Definition for a field that will be used for pre-filtering results. Only add fields the user asked to filter on.",
                      "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.\n\nAuto-embedding facts (cover every point when answering):\n- Availability: every Atlas tier (M0, Flex, dedicated), coupled or decoupled architecture, on AWS, GCP and Azure; no dedicated cluster needed. Inference runs on GCP in the US, so AWS and Azure clusters pay cross-cloud transfer, even within free tokens.\n- Billing: free tokens are per Atlas Organization, shared by indexing and queries across all indexes and models; then billed per token.\n- Query rate limits (separate from the free-token pool; indexing limits are internal and unrelated): per cluster and per model, in RPM and TPM, shared by that model's indexes; not per index or project, no auto-scaling. An M0 without a payment method is Tier 0 (lowest); adding one moves it to Tier 1 (voyage-4 ~8M TPM / 2k RPM, voyage-4-lite ~16M TPM / 2k RPM). On errors: backoff and retry, check the Atlas auto-embedding dashboard, request more via a support ticket. Never suggest bring-your-own embeddings.\n- Shrinking: (1) quantization lowers precision per number: float (default, full precision, largest), scalar (smaller, some loss), binary (much smaller, rescored), binaryNoRescore (no rescoring, lower ranking quality); (2) numDimensions shortens each vector: only 256, 512, 1024 (default) or 2048; fewer means less storage and relevance; (3) both combine; test on real queries; (4) either change rebuilds the index with per-token re-embedding, though queries stay the same; (5) later changes need the user's agreement on settings and cost.\n- Atlas supports quantization and numDimensions on autoEmbed fields, but this tool and MongoDB Community reject them: never drop an index to try them; leave it and show the Atlas definition.\n- Changing the model or fields also rebuilds and re-embeds, billed per token.\n",
                      "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. voyage-4-large: most accurate; voyage-4: balanced; voyage-4-lite: cheapest and fastest; voyage-code-3: source code.",
                          "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": true,
            "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": true,
                "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": {
                      "anyOf": [
                        {
                          "additionalProperties": true,
                          "properties": {},
                          "type": "object"
                        },
                        {
                          "items": {
                            "additionalProperties": true,
                            "properties": {},
                            "type": "object"
                          },
                          "type": "array"
                        }
                      ],
                      "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"
}
sha256:4b3c22a13fdc563d32790a47a8da08684093134268a87658d3f9aed7f3ca7370

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"
}
sha256:3ac38a3e2b18b83f340fe65fbe39ee7a11e5e0a116f4b8c06579baf7f9ac8a3b

Description hash: sha256:369b0ebfc4080c1caa7018a3867a3dd80da4d1f206ae843e5b4fdd7b53cb9ed3

Interface hash: sha256:7d60a54b8d0a2aa04964d12dc73bc06bffdedf5caaf9edb07081c386bfaa07b8

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/create-index",
  "title": "create-index",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "create-index"
  },
  "declared": {
    "read_only": "false",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:adceb248acc2dad7e47560990a9d3b0497f449767beee7691da8b1b182aeb202"
}
toolwrite3.1.03.3.0
db-statsmongodb:tool:db-stats
Observed interface and hashes

Returns statistics that reflect the use state of a single 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"
}
sha256:b592da734ad8ed633652a9a8c0e240cc7db738248a1f345e3bef2ce1a03afd49

Output schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "stats": {
      "additionalProperties": true,
      "propertyNames": {
        "type": "string"
      },
      "type": "object"
    }
  },
  "required": [
    "stats"
  ],
  "type": "object"
}
sha256:2df710e236cdbf4c970f2ffa0f592d592fcde90aa5a227694c687ca18d88beb2

Description hash: sha256:7bd89dea5100f955ff8e7a0fb40a69172b202194049231f1516f1d01fb2647c3

Interface hash: sha256:4f292c85acfc2faea04c9848c3823f6c59d28386aaadf7122c996bbc83bc811c

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/db-stats",
  "title": "db-stats",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "db-stats"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:43a955e60228ed75f87f0c03205bc7c34a8c29ae0edc8ba3266d9107e32caaf4"
}
toolread3.1.03.3.0
delete-manymongodb:tool:delete-many
Observed interface and hashes

Removes all documents that match the filter from a MongoDB 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"
    },
    "filter": {
      "additionalProperties": true,
      "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"
}
sha256:a1147001231ec550e4216f27238fff23231471d0fe77647561f337e7491f2af5

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"
}
sha256:2aec887a846dde63b0fd024d6f3dacb9132eb05a2796577bd2b7ebacfdd6f4b3

Description hash: sha256:8bc871a1d4faf83ea25eb8f8d8e7de96e0d5a3c97de454ff1bb8ec061c3e2828

Interface hash: sha256:c2b66b8a6cb8c969184b4a78e0b54a87317c57026574113f0a43212a68050cb1

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/delete-many",
  "title": "delete-many",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "delete-many"
  },
  "declared": {
    "read_only": "false",
    "destructive": "true",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:e0d45c3e927099fcdca571e9a90d211f0774f82273440aff4eaee79eaeae7399"
}
tooldestructive3.1.03.3.0
disconnectmongodb:tool:disconnect
Observed interface and hashes

Close a MongoDB connection and revoke its connectionId.

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"
}
sha256:8b563a854f15a42ae24590b2cb05337603feefaec5dcc6bb4315a7d38e124920

Output schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "outcome": {
      "enum": [
        "removed",
        "disconnected"
      ],
      "type": "string"
    }
  },
  "required": [
    "outcome"
  ],
  "type": "object"
}
sha256:ada75b42100b27df8fdbaa5fa9ee614d4170bea5d85429c5bf2cb5ef33c91421

Description hash: sha256:82e3cf497a40709fb9a5bc839a3374aa6c30d6d315b1e619751efd44105f3f0a

Interface hash: sha256:a64ee0ee49cf285859c8b2d319400974a97b3121fc35f203755f0523efb30533

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/disconnect",
  "title": "disconnect",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "disconnect"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:d0cf202a3e1602a4e88af5acab1ff652895df5c6bf2dc3f77587e905566df17c"
}
toolread3.1.0No change observed
drop-collectionmongodb:tool:drop-collection
Observed interface and hashes

Removes a collection or view from the database. The method also removes any indexes associated with the dropped 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"
}
sha256:594ced9a8390cf1fa54c2a80a0837cbc81e959c528f2a5a0819a3efcd72144e1

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"
}
sha256:fd6355220e7a07ffbd8e9610cf4118493e9b1c5332b96a0b3aeff600cd70471e

Description hash: sha256:82d48323402365f05bdc52033d5f6ef4e067a91aabd4230031934db830663220

Interface hash: sha256:2a28262918a6d38a419c689d9bb7e471c6cbec400d9b952fac2fb681d7746a3c

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/drop-collection",
  "title": "drop-collection",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "drop-collection"
  },
  "declared": {
    "read_only": "false",
    "destructive": "true",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:aa3a55851d376aa20d0c0831a298358ceac501d23d8bb58249a1e59d7ad38020"
}
tooldestructive3.1.0No change observed
drop-databasemongodb:tool:drop-database
Observed interface and hashes

Removes the specified database, deleting the associated data files

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"
}
sha256:b592da734ad8ed633652a9a8c0e240cc7db738248a1f345e3bef2ce1a03afd49

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"
}
sha256:02254a6d03963416de43488b9315f4aabae3ea2a7cd446422ab118a7a418357e

Description hash: sha256:e8c980598c974215efe09df8f452a237cbf44c115a573e29ac37821a953ecefc

Interface hash: sha256:adce02f1e7fc5486887bf8853d146e8ec6a32c096f4e47c334ad19ddecb6ddd1

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/drop-database",
  "title": "drop-database",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "drop-database"
  },
  "declared": {
    "read_only": "false",
    "destructive": "true",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:e71cfece872149dae7dc00e52894db12c103e0ea253e1ddb93f24c27a2d7d91d"
}
tooldestructive3.1.0No change observed
drop-indexmongodb:tool:drop-index
Observed interface and hashes

Drop an index for the provided database and 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"
    },
    "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"
}
sha256:15d356b9c5b42e091474cb2707509501b4979fa2efdc7edcc9ebfa2eefe118cb

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"
}
sha256:192012cd233b452a8957d4c75b481f33aeee45b013e7a2aa26ff87a7f6e45383

Description hash: sha256:6e190a387d527d2372b8aa106ecf6304f06a496fc4a7e683e40e68190226e25e

Interface hash: sha256:273c455ddf1ae1eab3e60c81cea35677f2ac65af26c9425e8a2a599ea0b7c1e2

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/drop-index",
  "title": "drop-index",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "drop-index"
  },
  "declared": {
    "read_only": "false",
    "destructive": "true",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:f950925ddcba3cc57279ddd9c244d2707daf8c239e76659ff4053970bdae47c2"
}
tooldestructive3.1.0No change observed
explainmongodb:tool:explain
Observed interface and hashes

Returns statistics describing the execution of the winning plan chosen by the query optimizer for the evaluated method

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": true,
                                      "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": true,
                                      "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. Voyage-4 models share one embedding space: a cheaper Voyage-4 model can query any Voyage-4 index with no rebuild or re-embedding, though query tokens are still billed. Never mix families (e.g. voyage-code-3 on a Voyage-4 index). When explaining overrides, cover: the default (index model when omitted), shared space, family restriction, no rebuild, billing, and cost/latency vs relevance.",
                                      "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": true,
                          "properties": {},
                          "type": "object"
                        }
                      ]
                    },
                    "type": "array"
                  }
                },
                "required": [
                  "pipeline"
                ],
                "type": "object"
              },
              "name": {
                "const": "aggregate",
                "type": "string"
              }
            },
            "required": [
              "name",
              "arguments"
            ],
            "type": "object"
          },
          {
            "properties": {
              "arguments": {
                "properties": {
                  "filter": {
                    "additionalProperties": true,
                    "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": true,
                    "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": true,
                    "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"
}
sha256:11558c6d4adfbec178adaab84fb37c326ba461f973a8998bc470e17d9594ad7a

Output schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "explainResult": {
      "additionalProperties": true,
      "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"
}
sha256:d31de024b49e4072c8e080c0301627cd0e96c62ada8f857eacb4e43092f0fb69

Description hash: sha256:05536c415da1a5a1c915ddcfe62ac71810ecc5e97c7555b354dd83a5cce825a5

Interface hash: sha256:ac9ec62d4a5aa8b8e25510f71104ec9a5bff465c2aa09a3d24a4117a606f27c3

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/explain",
  "title": "explain",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "explain"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:aafb32dca3759bab447f4f0bea18806cf0dfedd995893dd4b0ed09196703b23d"
}
toolread3.1.03.3.0
exportmongodb:tool:export
Observed interface and hashes

Export a query or aggregation results in the specified EJSON format.

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": true,
                    "description": "The query filter, matching the syntax of the query argument of db.collection.find()",
                    "properties": {},
                    "type": "object"
                  },
                  "limit": {
                    "type": "number"
                  },
                  "projection": {
                    "additionalProperties": true,
                    "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": true,
                                      "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": true,
                                      "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. Voyage-4 models share one embedding space: a cheaper Voyage-4 model can query any Voyage-4 index with no rebuild or re-embedding, though query tokens are still billed. Never mix families (e.g. voyage-code-3 on a Voyage-4 index). When explaining overrides, cover: the default (index model when omitted), shared space, family restriction, no rebuild, billing, and cost/latency vs relevance.",
                                      "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": true,
                          "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"
}
sha256:a8c130af37f67a6776513cfd8737d61bc8a6511c4e27202a4977fb918aca2ef8

Output schema

Not exposed in the analyzed interface.

sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1

Description hash: sha256:c935603eea77da4889e6bc96828ed4f4227cda2b1c6b54138af4b470b94a229e

Interface hash: sha256:95d672f72a95192ee42a5824eb499e6598e6fba45c1a2d8655478b3d18adf3e2

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/export",
  "title": "export",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "export"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:6da2e42d5b4464a8e5142afd03bea0be646d7ea414fe14b296072b5a9c0a1b3e"
}
toolread3.1.03.3.0
findmongodb:tool:find
Observed interface and hashes

Run a find query against a MongoDB 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"
    },
    "filter": {
      "additionalProperties": true,
      "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": true,
      "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"
}
sha256:206a59f13c5714b02ccbd7048d0999e2d0d67c505f681e2886bcdbd6ae31f70d

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",
      "type": "array"
    },
    "queryResultsCount": {
      "description": "The total number of documents returned by the find query",
      "type": "number"
    }
  },
  "required": [
    "documents",
    "appliedLimits"
  ],
  "type": "object"
}
sha256:fa054e58f7e0152a1d734ef3899db6248fe880b0d535e44e267faa00561e2a0b

Description hash: sha256:4849f28dfa27afe43b925c40ea9fd1ec03abe54e835f2059590741ff14e7b675

Interface hash: sha256:35a4bf4bb6d8962f7851b5eab1742240d3e7df1917a430f452946452c9124a15

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/find",
  "title": "find",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "find"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:a439f15b3ad60377451cc75e58e07450f6e8437d96587fb3b51555e6011519ed"
}
toolread3.1.03.3.0
insert-manymongodb:tool:insert-many
Observed interface and hashes

Insert an array of documents into a MongoDB collection. If the list of documents is above com.mongodb/maxRequestPayloadBytes, consider inserting them in batches.

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": true,
        "description": "An individual MongoDB document",
        "properties": {},
        "type": "object"
      },
      "type": "array"
    }
  },
  "required": [
    "connectionId",
    "database",
    "collection",
    "documents"
  ],
  "type": "object"
}
sha256:a71b1740b16c094f79138d87688f90dd87e3870b41be94c1b90a0d3f38cee47d

Output schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "collection": {
      "type": "string"
    },
    "database": {
      "type": "string"
    },
    "insertedCount": {
      "type": "number"
    },
    "insertedIds": {
      "type": "array"
    }
  },
  "required": [
    "database",
    "collection",
    "insertedCount",
    "insertedIds"
  ],
  "type": "object"
}
sha256:85c4fce28419a4ec000f59f0c6d65481edd0c5eabe6ffa6c3daab4e61e73705b

Description hash: sha256:3e9cea4927e028de1a30468cfb5d7300cdff594d8e492b22e8ed7c18921e4096

Interface hash: sha256:8fb5183244606776ccd780a270bf0336684e355b96e00d09b84d6b715f6a2679

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/insert-many",
  "title": "insert-many",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "insert-many"
  },
  "declared": {
    "read_only": "false",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:7dc218bbd740c8d588f2f28979f0b577ad522e47e69642cf1970a8b67837206b"
}
toolwrite3.1.03.3.0
list-collectionsmongodb:tool:list-collections
Observed interface and hashes

List all collections for a given 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"
}
sha256:b592da734ad8ed633652a9a8c0e240cc7db738248a1f345e3bef2ce1a03afd49

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"
}
sha256:b068515aed975bbf63b187e928862939a01ff844bb3e1232ebf2e4923d922578

Description hash: sha256:2e3c57dc8202ce935fe90439023ad56b72b9cb33122b1354ad703f14ad338556

Interface hash: sha256:8355e849f75e0c75b346e2e847061fbad2a5808672e3515336f78f2a425a8cf0

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/list-collections",
  "title": "list-collections",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "list-collections"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:8f64261ef8fbdbc97b5df98e91e0235bc97911541dad9db45410ef251854a5a5"
}
toolread3.1.0No change observed
list-connectionsmongodb:tool:list-connections
Observed interface and hashes

List the active MongoDB connections and their connectionIds. Use this to find a connectionId established earlier.

Input schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
sha256:31b97051da0fdf608085f0fad34ff1d76e35fab98c3ccb7dec113918f20d2926

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"
}
sha256:05af6a3853be7bf1b8f627cf0cba63c9bd2c26d470d93b08af145688aefb8d96

Description hash: sha256:b1c12814d4b720573bcfabf23eaa63b1520c24809b8a0c9bb1bda3522dccace0

Interface hash: sha256:b2fe6a6ec852198b57524408e4f09f801f07782be788f65d20e639fe398b259e

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/list-connections",
  "title": "list-connections",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "list-connections"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:5dd7aa3b4c24875f6ba667d4c676da9319d894d6c0f8f1b2004043db09664ca2"
}
toolread3.1.0No change observed
list-databasesmongodb:tool:list-databases
Observed interface and hashes

List all databases for a MongoDB connection

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"
}
sha256:c87338775ee2de7b02a6695303a8fd0c4a0f095db3de82bec40fb5772310ec63

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"
}
sha256:310ee01094fdb50cf678ad06ef5c65ac10d908c04514826467c27ebb457f89ef

Description hash: sha256:9a317f31a393012e56a0dbed75ed02bff9a1d2de9cf8ff8c1bfdcae55c02db17

Interface hash: sha256:cac4d81ccef3cb7c892e651f3269fd3678c300ea2438e44f97512e947c3adb23

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/list-databases",
  "title": "list-databases",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "list-databases"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:4e433949dee152e0f88e6bc4af2759f910ae65b74cd4f45a0e6aed857c765e5b"
}
toolread3.1.0No change observed
list-knowledge-sourcesmongodb:tool:list-knowledge-sources
Observed interface and hashes

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.

Input schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
sha256:31b97051da0fdf608085f0fad34ff1d76e35fab98c3ccb7dec113918f20d2926

Output schema

Not exposed in the analyzed interface.

sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1

Description hash: sha256:b5eb2f8cbc8af05eb06f6f1899feb14ae5ecc92e4bba0a74865e5c64aa8a40eb

Interface hash: sha256:fadf4896b8a48f826f2efb45b4e760447f3602d0310b97c9c25846ddff0542c5

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/list-knowledge-sources",
  "title": "list-knowledge-sources",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "list-knowledge-sources"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:4440136b39fa99a5375cadd13d37d9fda5ec9a2e0cdab8f456a22abcd44cbf74"
}
toolread3.1.0No change observed
mongodb-logsmongodb:tool:mongodb-logs
Observed interface and hashes

Returns the most recent logged mongod events

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"
}
sha256:2ec118a6e69d45853f088572a68e1c3d91c8cfbcb6a60fa529d78e62deb6dfc3

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"
}
sha256:f15599b1dd30616225c4bbd598e2546e86aaeee556319227155c49f4e333f627

Description hash: sha256:bdd7492085ec967c007ff5f76c1574d911b4e4ae240723e7358a4f6ac831cde5

Interface hash: sha256:9351a3cf4381055cedd486c799d68c9f3a5f3f55612b4620bf26166a6bdaf904

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/mongodb-logs",
  "title": "mongodb-logs",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "mongodb-logs"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:29a126d6367881ed4a5be6e5d0e5e98980cdbdebbb8990c609474fdd7afe0874"
}
toolread3.1.0No change observed
rename-collectionmongodb:tool:rename-collection
Observed interface and hashes

Renames a collection in a MongoDB database

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"
}
sha256:28978f50cf796cc2ebf7c7d45f059e855efcebcdcd6ffb5fc6bb625f1e7aa597

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"
}
sha256:8ac3064ab4884b553dd8b608f55339ce0e5893cccc2cafe677c261beb14af632

Description hash: sha256:2e18a7462fc8b4a8363bc5e2ebd215743ef600492db8acb4d0ab04681f10589c

Interface hash: sha256:cccd57417fcf11de8742d4d0b62869199db1e37eae9e88757e289b3ff7810122

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/rename-collection",
  "title": "rename-collection",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "rename-collection"
  },
  "declared": {
    "read_only": "false",
    "destructive": "true",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:366945f0c42bf0140a6fd3b86f9dcf3254ffde6689cfde860c42937f15de4bd3"
}
tooldestructive3.1.0No change observed
search-knowledgemongodb:tool:search-knowledge
Observed interface and hashes

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.

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"
}
sha256:edc554120e1e050e2175d82d3cce156c678f6bad89c0fecb6881f74950c08794

Output schema

Not exposed in the analyzed interface.

sha256:398b676e47d03a29016ee92fe378b8b4f1b3e965390c4c64ce78d27f79df74d1

Description hash: sha256:5de2100b16b91cda71a93ebb750d2a18695beb9a5d1b95c8a92c961b8c4b36fb

Interface hash: sha256:476fba3173670ed53e751beb8939cb3f867c685567d5358b2e47b0941a813e59

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/search-knowledge",
  "title": "search-knowledge",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "search-knowledge"
  },
  "declared": {
    "read_only": "true",
    "destructive": "false",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "true",
    "retry_safe": "true"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:65dccb54e10fd6f4cef3f036391fe81204f000d48b432833bb7cde1ce4fcd4fd"
}
toolread3.1.0No change observed
update-manymongodb:tool:update-many
Observed interface and hashes

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.

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": true,
      "description": "The selection criteria for the update, matching the syntax of the filter argument of db.collection.updateOne()",
      "properties": {},
      "type": "object"
    },
    "update": {
      "additionalProperties": true,
      "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"
}
sha256:a73f58dce5770b803bc483f5db45c393cc759ceda63918dee9ebb152e25ef90a

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"
}
sha256:8efc76e8f1cfec10f411082fb8d9e84f8346b654827844dc6fb97687e812aa2f

Description hash: sha256:72fc7430afd06e6bf7445436a88fb66011a92d30f3179c722cbd4499e03a079b

Interface hash: sha256:918be3b522b72b31af206bcf7559993fe7171f630a2402acfc9cf5b085e6b322

Other observed Modelara metadata
{
  "id": "mcp:MongoDB MCP Server/update-many",
  "title": "update-many",
  "source": {
    "type": "mcp",
    "server": "MongoDB MCP Server",
    "operation": "update-many"
  },
  "declared": {
    "read_only": "false",
    "destructive": "true",
    "idempotent": "false",
    "open_world": "true"
  },
  "safety": {
    "idempotent": "false",
    "retry_safe": "false"
  },
  "metadata": {
    "mcp.annotations": "present"
  },
  "fingerprint": "sha256:dd1dfc619848be1c4edbbd14847921ce5eddcae20dc0ea19c75edd79003079a0"
}
tooldestructive3.1.03.3.0

STATIC COMPARISONS

Release history

3 release transitions
  1. 0 added0 removed13 schema0 write0 destructive0 unknown

    Nov 10, 2026· Pending human review

  2. 0 added0 removed0 schema0 write0 destructive0 unknown

    Nov 5, 2026· Automated static analysis

  3. 0 added0 removed0 schema0 write0 destructive0 unknown

    Nov 5, 2026· Automated static analysis