de en es ja ko ru zh

MongoDB

Name: MongoDB
Author: kiliczsh

by kiliczsh

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

MCP MongoDB Server

NPM-Version NPM-Downloads NPM-Lizenz Schmiedeabzeichen

Ein Model Context Protocol-Server, der LLMs die Interaktion mit MongoDB-Datenbanken ermöglicht. Dieser Server bietet Funktionen zur Überprüfung von Sammlungsschemata und zur Ausführung von MongoDB-Operationen über eine standardisierte Schnittstelle.

Demo

MCP MongoDB Server Demo | Claude Desktop

Related MCP server: MongoDB MCP Server for LLMs

Hauptmerkmale

Intelligente Objekt-ID-Behandlung

Intelligente Konvertierung zwischen String-IDs und MongoDB ObjectId
Konfigurierbar mit dem Parameter objectIdMode :
- "auto" : Konvertierung basierend auf Feldnamen (Standard)
- "none" : Keine Konvertierung
- "force" : Erzwingt die ObjectId aller String-ID-Felder

Flexible Konfiguration

Umgebungsvariablen :
- MCP_MONGODB_URI : MongoDB-Verbindungs-URI
- MCP_MONGODB_READONLY : Aktiviert den Nur-Lese-Modus, wenn auf „true“ gesetzt
Befehlszeilenoptionen :
- --read-only oder -r : Verbindung im schreibgeschützten Modus herstellen

Schreibgeschützter Modus

Schutz vor Schreiboperationen (Update, Insert, CreateIndex)
Nutzt die sekundäre Lesepräferenz von MongoDB für optimale Leistung
Ideal für die sichere Verbindung mit Produktionsdatenbanken

MongoDB-Operationen

Lesevorgänge :
- Abfragedokumente mit optionaler Ausführungsplananalyse
- Ausführen von Aggregationspipelines
- Zählen Sie Dokumente, die den Kriterien entsprechen
- Abrufen von Sammlungsschemainformationen
Schreibvorgänge (wenn nicht im Nur-Lese-Modus):
- Dokumente aktualisieren
- Neue Dokumente einfügen
- Erstellen von Indizes

LLM-Integration

Sammlungsvervollständigungen für eine verbesserte LLM-Interaktion
Schemainferenz für ein besseres Kontextverständnis
Sammlungsanalyse für Dateneinblicke

Installation

Globale Installation

npm install -g mcp-mongo-server

Für die Entwicklung

# Clone repository
git clone https://github.com/kiliczsh/mcp-mongo-server.git
cd mcp-mongo-server

# Install dependencies
npm install

# Build
npm run build

# Development with auto-rebuild
npm run watch

Verwendung

Grundlegende Verwendung

# Start server with MongoDB URI
npx -y mcp-mongo-server mongodb://muhammed:kilic@localhost:27017/database

# Connect in read-only mode
npx -y mcp-mongo-server mongodb://muhammed:kilic@localhost:27017/database --read-only

Umgebungsvariablen

Sie können den Server mithilfe von Umgebungsvariablen konfigurieren. Dies ist besonders nützlich für CI/CD-Pipelines, Docker-Container oder wenn Sie keine Verbindungsdetails in Befehlsargumenten offenlegen möchten:

# Set MongoDB connection URI
export MCP_MONGODB_URI="mongodb://muhammed:kilic@localhost:27017/database"

# Enable read-only mode
export MCP_MONGODB_READONLY="true"

# Run server (will use environment variables if no URI is provided)
npx -y mcp-mongo-server

Verwenden von Umgebungsvariablen in der Claude Desktop-Konfiguration:

{
  "mcpServers": {
    "mongodb-env": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-mongo-server"
      ],
      "env": {
        "MCP_MONGODB_URI": "mongodb://muhammed:kilic@localhost:27017/database",
        "MCP_MONGODB_READONLY": "true"
      }
    }
  }
}

Verwenden von Umgebungsvariablen mit Docker:

# Build
docker build -t mcp-mongo-server .

# Run
docker run -it -d -e MCP_MONGODB_URI="mongodb://muhammed:kilic@localhost:27017/database" -e MCP_MONGODB_READONLY="true" mcp-mongo-server

# or edit docker-compose.yml and run
docker-compose up -d

Integration mit Claude Desktop

Manuelle Konfiguration

Fügen Sie die Serverkonfiguration zur Konfigurationsdatei von Claude Desktop hinzu:

MacOS : ~/Library/Application Support/Claude/claude_desktop_config.json Windows : %APPDATA%/Claude/claude_desktop_config.json

Ansatz mit Befehlszeilenargumenten:

{
  "mcpServers": {
    "mongodb": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-mongo-server",
        "mongodb://muhammed:kilic@localhost:27017/database"
      ]
    },
    "mongodb-readonly": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-mongo-server",
        "mongodb://muhammed:kilic@localhost:27017/database",
        "--read-only"
      ]
    }
  }
}

Ansatz mit Umgebungsvariablen:

{
  "mcpServers": {
    "mongodb": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-mongo-server"
      ],
      "env": {
        "MCP_MONGODB_URI": "mongodb://muhammed:kilic@localhost:27017/database"
      }
    },
    "mongodb-readonly": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-mongo-server"
      ],
      "env": {
        "MCP_MONGODB_URI": "mongodb://muhammed:kilic@localhost:27017/database",
        "MCP_MONGODB_READONLY": "true"
      }
    }
  }
}

GitHub-Paketnutzung:

{
  "mcpServers": {
    "mongodb": {
      "command": "npx",
      "args": [
        "-y",
        "github:kiliczsh/mcp-mongo-server",
        "mongodb://muhammed:kilic@localhost:27017/database"
      ]
    },
    "mongodb-readonly": {
      "command": "npx",
      "args": [
        "-y",
        "github:kiliczsh/mcp-mongo-server",
        "mongodb://muhammed:kilic@localhost:27017/database",
        "--read-only"
      ]
    }
  }
}

Integration mit Windsurf und Cursor

Der MCP MongoDB-Server kann mit Windsurf und Cursor auf ähnliche Weise wie Claude Desktop verwendet werden.

Windsurf-Konfiguration

Fügen Sie den Server zu Ihrer Windsurf-Konfiguration hinzu:

{
  "mcpServers": {
    "mongodb": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-mongo-server",
        "mongodb://muhammed:kilic@localhost:27017/database"
      ]
    }
  }
}

Cursorkonfiguration

Fügen Sie für Cursor die Serverkonfiguration zu Ihren Einstellungen hinzu:

{
  "mcpServers": {
    "mongodb": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-mongo-server",
        "mongodb://muhammed:kilic@localhost:27017/database"
      ]
    }
  }
}

Sie können den Ansatz mit Umgebungsvariablen auch sowohl mit Windsurf als auch mit Cursor verwenden und dabei dem gleichen Muster folgen, das in der Claude Desktop-Konfiguration gezeigt wird.

Automatisierte Installation

Schmiedearbeiten verwenden :

npx -y @smithery/cli install mcp-mongo-server --client claude

Verwenden von mcp-get :

npx @michaellatman/mcp-get@latest install mcp-mongo-server

Verfügbare Tools

Abfragevorgänge

Abfrage : Führen Sie MongoDB-Abfragen aus

{
  collection: "users",
  filter: { age: { $gt: 30 } },
  projection: { name: 1, email: 1 },
  limit: 20,
  explain: "executionStats"  // Optional
}

aggregate : Führen Sie Aggregationspipelines aus

{
  collection: "orders",
  pipeline: [
    { $match: { status: "completed" } },
    { $group: { _id: "$customerId", total: { $sum: "$amount" } } }
  ],
  explain: "queryPlanner"  // Optional
}

count : Zählt übereinstimmende Dokumente

{
  collection: "products",
  query: { category: "electronics" }
}

Schreibvorgänge

Update : Dokumente ändern

{
  collection: "posts",
  filter: { _id: "60d21b4667d0d8992e610c85" },
  update: { $set: { title: "Updated Title" } },
  upsert: false,
  multi: false
}

einfügen : Neue Dokumente hinzufügen

{
  collection: "comments",
  documents: [
    { author: "user123", text: "Great post!" },
    { author: "user456", text: "Thanks for sharing" }
  ]
}

createIndex : Sammlungsindizes erstellen

{
  collection: "users",
  indexes: [
    {
      key: { email: 1 },
      unique: true,
      name: "email_unique_idx"
    }
  ]
}

Systembetrieb

serverInfo : MongoDB-Serverdetails abrufen

{
  includeDebugInfo: true  // Optional
}

Debuggen

Da MCP-Server über Standarddio kommunizieren, kann das Debuggen schwierig sein. Verwenden Sie den MCP-Inspektor für bessere Übersicht:

npm run inspector

Dadurch wird eine URL für den Zugriff auf die Debugging-Tools in Ihrem Browser bereitgestellt.

Ausführen von Evaluierungen

Das Evals-Paket lädt einen MCP-Client, der anschließend die Datei index.ts ausführt, sodass zwischen den Tests kein Neuaufbau erforderlich ist. Sie können Umgebungsvariablen laden, indem Sie dem Befehl npx voranstellen. Die vollständige Dokumentation finden Sie hier .

OPENAI_API_KEY=your-key  npx mcp-eval src/evals/evals.ts src/schemas/tools.ts

Lizenz

Dieser MCP-Server ist unter der MIT-Lizenz lizenziert. Das bedeutet, dass Sie die Software unter den Bedingungen der MIT-Lizenz frei verwenden, ändern und verbreiten dürfen. Weitere Informationen finden Sie in der LICENSE-Datei im Projekt-Repository.

Available Tools

8 tools

aggregateB

Execute a MongoDB aggregation pipeline with optional execution plan analysis

ParametersJSON Schema

Name	Required	Description	Default
`explain`	No	Optional: Get aggregation execution information (queryPlanner, executionStats, or allPlansExecution)
`pipeline`	Yes	Aggregation pipeline stages
`collection`	Yes	Name of the collection to aggregate
`objectIdMode`	No	Control how 24-character hex strings are handled	auto

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It does not disclose whether the tool is read-only, can write via stages like $merge, or any potential side effects, performance implications, or required permissions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence of 12 words directly states the core functionality. No extraneous information, efficiently front-loads the action and optional feature.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite being a complex tool (aggregation pipeline), the description lacks details on output format, error handling, potential performance costs, or the impact of the objectIdMode parameter. No output schema compounds the incompleteness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

All four parameters are fully described in the input schema (100% coverage). The description adds minimal extra context, only mentioning 'optional execution plan analysis' which maps to the explain parameter. No further clarification on pipeline construction or objectIdMode behavior.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool executes a MongoDB aggregation pipeline with optional execution plan analysis. It uses specific verb 'execute' and resource 'aggregation pipeline', distinguishing it from sibling tools like query, count, or insert.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives such as 'query' or 'count'. The description does not mention scenarios or limitations, leaving the agent to infer usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

countC

Count documents in a collection matching a query

ParametersJSON Schema

Name	Required	Description	Default
`hint`	No	Index hint
`skip`	No	Docs to skip before counting
`limit`	No	Max documents to count
`query`	No	Query filter to count
`collation`	No	Collation rules for comparison
`maxTimeMS`	No	Max execution time
`collection`	Yes	Collection name
`readConcern`	No	Read concern option
`objectIdMode`	No	Control how 24-character hex strings are handled	auto

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It only states the basic operation without detailing any side effects (none expected for a count), return format, or constraints (e.g., counting behavior with skip/limit). The agent cannot infer that this is a read-only operation or what the output structure is.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the core function. However, it is overly terse and lacks structured details that would aid the agent, such as separating purpose from usage notes. Score reflects conciseness but slight under-information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 9 parameters, no output schema, and no annotations, the description is insufficiently complete. It omits essential information like the return type (a count number), whether the count is approximate or exact, and behavior with optional parameters like skip/limit. A more complete description would provide contextual completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% coverage with descriptions for all 9 parameters. The description adds no additional parameter semantics beyond what is already in the schema. Per guidelines, baseline is 3 when schema coverage is high, and no extra value is provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'count' and the resource 'documents in a collection matching a query', which accurately defines the tool's purpose. However, it does not explicitly distinguish this tool from sibling tools like 'aggregate' or 'query', which could also perform counting.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives (e.g., 'aggregate' for more complex aggregations). There are no examples, prerequisites, or exclusions mentioned, leaving the agent without sufficient context to choose appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

createIndexB

Create one or more indexes on a MongoDB collection

ParametersJSON Schema

Name	Required	Description	Default
`indexes`	Yes	Array of index specifications
`collection`	Yes	Name of the collection to create indexes on
`commitQuorum`	No	Number of members required to create the index
`objectIdMode`	No	Control how 24-character hex strings are handled	auto
`writeConcern`	No	Write concern for index creation

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only states the action without mentioning side effects like blocking operations, performance implications, or permission requirements. This is inadequate for a mutation tool that can significantly affect database behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single concise sentence that is front-loaded with the core action. However, it is extremely brief given the tool's complexity. It earns its place but could benefit from a bit more structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 5 parameters including nested objects and no output schema, the description is insufficient. It does not explain that multiple indexes can be created, the return behavior, or important aspects like background building. The agent lacks key information for correct usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% with each parameter having a description. The tool description adds no additional semantics beyond the schema. Baseline of 3 is appropriate as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the purpose: creating one or more indexes on a MongoDB collection. The verb 'create' and resource 'indexes on a MongoDB collection' are specific, and the tool is distinct from siblings like 'aggregate' or 'insert' that do not create indexes.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives, or prerequisites for index creation. The description lacks context about when indexes should be created or potential impacts, leaving the agent without decision support.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

insertB

Insert one or more documents into a MongoDB collection

ParametersJSON Schema

Name	Required	Description	Default
`ordered`	No	If true, perform ordered insert. If false, insert unordered
`documents`	Yes	Array of documents to insert
`collection`	Yes	Name of the collection to insert into
`objectIdMode`	No	Control how 24-character hex strings are handled	auto
`writeConcern`	No	Write concern for the insert operation
`bypassDocumentValidation`	No	Allow insert to bypass schema validation

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description must disclose behavior. It lacks details on handling duplicate _id errors, return values, or performance implications. Only states basic insert action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One short sentence with no waste, but could be more informative without being verbose. Front-loads the core action.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 6 parameters including nested objects and no output schema, the description is insufficient. It should mention error handling, return format, and parameter default behaviors.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. Description adds no extra meaning beyond the schema; it doesn't explain parameters like ordered, objectIdMode, or writeConcern.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb 'Insert' and the resource 'MongoDB collection', with 'one or more documents' specifying scope. It distinguishes from siblings like query (read) and update (modify) with a specific insert action.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives (e.g., update for modifying, query for reading). No prerequisites or context about required permissions or collection existence.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

listCollectionsB

List all collections in the MongoDB database

ParametersJSON Schema

Name	Required	Description	Default
`filter`	No	Filter for collections
`nameOnly`	No	If true, return only collection names
`objectIdMode`	No	Control how 24-character hex strings are handled	auto

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so the description carries full burden. It describes 'list' implying read-only, but fails to disclose behavior like pagination, authentication requirements, or how parameters like 'objectIdMode' affect execution.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single concise sentence that gets to the point. However, it could front-load more critical information like the database context, but for a simple tool it is appropriately sized.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, and the description does not explain return values (e.g., list of names vs full documents). The 'nameOnly' parameter hints at different outputs, but this is not clarified. For a list tool with multiple parameters, more detail is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description adds no extra meaning beyond the schema; it simply restates the tool's purpose without detailing parameter usage or constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific verb 'List' and resource 'collections in the MongoDB database', which distinguishes it from sibling tools like 'aggregate' or 'insert' that perform different operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool vs alternatives. It does not mention contexts where other tools like 'query' might be more appropriate, nor any conditions for using this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

queryB

Execute a MongoDB query with optional execution plan analysis

ParametersJSON Schema

Name	Required	Description	Default
`limit`	No	Maximum number of documents to return
`filter`	No	MongoDB query filter
`explain`	No	Optional: Get query execution information
`collection`	Yes	Name of the collection to query
`projection`	No	Fields to include/exclude
`objectIdMode`	No	Control how 24-character hex strings are handled	auto

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must disclose behaviors. It only states execution of a query, but does not specify if this is read-only, side effects, permission needs, or performance implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence that is direct and front-loaded with the core action. No unnecessary words, and the optional analysis is mentioned immediately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite having 6 parameters and no output schema, the description does not explain return values, pagination, or behavior for required parameters. It is too minimal for a complex MongoDB query operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so each parameter is already documented. The description adds minor value by linking 'execution plan analysis' to the explain parameter, but does not provide additional semantic context.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool executes a MongoDB query with optional execution plan analysis. The verb 'Execute' and resource 'MongoDB query' are specific, and the mention of execution plan analysis distinguishes it from basic query tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus siblings like aggregate or count. The description does not mention appropriate scenarios, prerequisites, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

serverInfoA

Get MongoDB server information including version, storage engine, and other details

ParametersJSON Schema

Name	Required	Description	Default
`includeDebugInfo`	No	Include additional debug information about the server

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries full burden. It correctly implies a read-only, non-destructive operation but does not disclose any specific behavioral traits such as authentication needs or rate limits. The effect of the optional parameter is not elaborated beyond the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that conveys the core purpose. It is front-loaded and concise, though it could be slightly more structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple info tool with one optional parameter and no output schema, the description is mostly complete, stating the type of information returned. It lacks details about return format or explicit read-only guarantee, but is still adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and the parameter already has a description. The tool description adds no additional meaning about the parameter beyond what the schema provides, so a baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool gets MongoDB server information and lists examples like version and storage engine, distinguishing it from sibling tools that perform data operations (query, insert, etc.).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives a clear purpose but does not explicitly state when or when not to use this tool versus alternatives. Context from sibling tools suggests usage, but no direct guidance is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

updateC

Update documents in a MongoDB collection

ParametersJSON Schema

Name	Required	Description	Default
`multi`	No	Update multiple documents that match the filter
`filter`	Yes	Filter to select documents to update
`update`	Yes	Update operations to apply ($set, $unset, $inc, etc.)
`upsert`	No	Create a new document if no documents match the filter
`collection`	Yes	Name of the collection to update
`objectIdMode`	No	Control how 24-character hex strings are handled	auto

TDQS

C2.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description solely must clarify behavior. It only states the operation type (update) but omits details like whether the tool returns the updated document, handles no-matches, or requires authentication. The rich schema parameters (multi, upsert) are not elaborated beyond their definitions.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single short sentence, which is concise but at the cost of informative detail. It does not front-load key behavioral cues (e.g., upsert support) and is thus minimal rather than optimally structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 6 parameters, nested objects, and no output schema, the description lacks completeness. It does not explain return values, error scenarios, or behavior of multi/upsert combinations, leaving significant gaps for an agent to use correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so each parameter has a description. The tool description adds no extra parameter context, meeting the baseline for high coverage. However, no additional semantic elaboration is provided for complex parameters like 'update' (MongoDB operators) or 'objectIdMode'.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool updates documents in a MongoDB collection using a clear verb-resource structure. However, it does not distinguish this tool from siblings like 'insert' (creates) or 'query' (reads), leaving some ambiguity about the specific operation scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as 'insert' for new documents or 'aggregate' for transformations. There is no mention of prerequisites, idempotency, or context-specific conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

8 tool updatesv1.0.0Apr 15, 2025
- First observedaggregate
- First observedcount
- First observedcreateIndex
- First observedinsert
- First observedlistCollections
- First observedquery
- First observedserverInfo
- First observedupdate

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.4/5.0

Disambiguation5/5

Each tool targets a distinct database operation: aggregation, counting, indexing, inserting, listing collections, querying, server info, and updating. No two tools have overlapping purposes.

Naming Consistency5/5

All tool names use lowercase with camelCase for multi-word terms (e.g., 'createIndex', 'listCollections', 'serverInfo'), following a consistent pattern of verb or verb_noun.

Tool Count5/5

8 tools cover core MongoDB operations (CRUD, aggregation, indexing, metadata) without being too few or excessive for a general-purpose database server.

Completeness2/5

The set lacks a tool for deleting documents or collections, which is a fundamental operation. Without 'delete' or 'remove', agents cannot complete typical data lifecycle actions, leaving a significant gap.

Maintenance

ActivitySlowing

ResponsivenessSlow

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Apideck MCP A
dev.apideck.mcp
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
Developer Tools
42
mcp COAuth
com.wix
A Model Context Protocol server for Wix AI tools
Developer Tools Content Management Systems App Automation
216
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
Mercado PagoOAuth
com.mercadopago.mcp
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Finance E-commerce & Retail App Automation
2

Related MCP Servers

MongoDB
Databases RAG Systems Developer Tools
QuantGeekDev
A
license
Not graded
quality
F
maintenance
A Model Context Protocol (MCP) server that enables LLMs to interact directly with MongoDB databases. Query collections, inspect schemas, and manage data seamlessly through natural language.
Updated a year ago (2025-03-15 23:32 UTC)
22
175
MIT
MongoDB MCP Server for LLMs
Databases RAG Systems
nickiiitu
A
license
Not graded
quality
D
maintenance
A Model Context Protocol server that enables LLMs to interact directly with MongoDB databases, allowing users to query collections, inspect schemas, and manage data through natural language.
Updated a year ago (2025-06-26 08:05 UTC)
22
2
MIT
MongoDB MCP Server for LLMs
Databases Autonomous Agents
vivek1612
A
license
Not graded
quality
D
maintenance
A Model Context Protocol server that enables LLMs to interact directly with MongoDB databases, allowing users to query collections, inspect schemas, and manage data through natural language.
Updated a year ago (2025-03-15 23:32 UTC)
22
MIT
MCP Database Server
Databases RAG Systems
manpreet2000
A
license
D
quality
D
maintenance
A Model Context Protocol server that enables LLMs to interact with databases (currently MongoDB) through natural language, supporting operations like querying, inserting, deleting documents, and running aggregation pipelines.
Updated a year ago (2025-03-23 16:56 UTC)
5
14
MIT

Appeared in Searches

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/kiliczsh/mcp-mongo-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server