How do I use MCP Server Boilerplate?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MCP Server Boilerplate show me how to add a new tool to my custom MCP server" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

MCP Server Boilerplate

by CaptainCrouton89

Overview Schema Related Servers Score Discussions

JavaScript

Remote

MCP Server Boilerplate

A starter template for building MCP (Model Context Protocol) servers. This boilerplate provides a clean foundation for creating your own MCP server that can integrate with Claude Desktop, Cursor, Claude Code, Gemini, and other MCP-compatible AI assistants.

Purpose

This boilerplate helps you quickly start building:

Custom tools for AI assistants
Resource providers for dynamic content
Prompt templates for common operations
Integration points for external APIs and services

Related MCP server: MCP Server Boilerplate

Features

Two example tools: "hello-world" and "get-mcp-docs"
TypeScript support with ES2022 target and ES modules
Multi-client installation scripts (Claude Desktop, Cursor, Claude Code, Gemini, etc.)
Automatic npm publishing workflow
Environment variable support via .env.local
Clean project structure with Zod validation

How It Works

This MCP server template provides:

A basic server setup using the MCP SDK
Example tool implementation
Build and installation scripts
TypeScript configuration for development

The included example demonstrates how to create a simple tool that takes a name parameter and returns a greeting.

Getting Started

Option 1: Use the Published Package (Recommended)

You can use this MCP server directly without cloning:

# Run the server directly with npx
npx @r-mcp/boilerplate

Option 2: Customize and Develop

# Clone the boilerplate
git clone <your-repo-url>
cd mcp-server-boilerplate

# Install dependencies
pnpm install

# Build the project
pnpm run build

# Start the server
pnpm start

Installation Scripts

This boilerplate includes convenient installation scripts for different MCP clients:

# Install to all MCP clients (Claude Desktop, Cursor, Claude Code, Gemini, MCP)
pnpm run install-server

# Install to specific clients
pnpm run install-desktop       # Claude Desktop
pnpm run install-cursor        # Cursor IDE
pnpm run install-code          # Claude Code CLI
pnpm run install-code-library  # Claude Code Library (~/.claude/mcp-library/)
pnpm run install-mcp           # Local .mcp.json for development

# You can also combine multiple targets:
node scripts/update-config.js cursor code desktop

These scripts will:

Build the project automatically (TypeScript compilation + chmod permissions)
Configure clients to use npx @r-mcp/<directory-name>@latest (auto-updating)
Only the local .mcp.json uses the development version (node dist/index.js)
Include environment variables from .env.local if present

Publishing Your Server

To publish your customized MCP server:

# Build, commit, and publish to npm in one command
pnpm run release

This script (scripts/build-and-publish.js) will:

Commit any pending changes first
Update package name to @r-mcp/<directory-name>
Update bin name to match directory
Increment patch version automatically
Build the TypeScript project
Commit version bump to git
Push to remote repository
Publish to npm with public access

Usage with MCP Clients

The installation scripts automatically configure your MCP clients. For reference, here's what gets added:

Production Clients (Claude Desktop, Cursor, Claude Code, Gemini):

{
  "mcpServers": {
    "boilerplate": {
      "command": "npx",
      "args": ["-y", "@r-mcp/boilerplate@latest"],
      "env": {
        // Environment variables from .env.local are included here
      }
    }
  }
}

Local Development (`.mcp.json`):

{
  "mcpServers": {
    "boilerplate": {
      "command": "node",
      "args": ["/absolute/path/to/dist/index.js"],
      "env": {
        // Environment variables from .env.local are included here
      }
    }
  }
}

After running installation scripts, restart your MCP client to connect to the server.

Customizing Your Server

Adding Tools

Tools are functions that the AI assistant can call. Here's the basic structure:

server.tool(
  "tool-name",
  "Description of what the tool does",
  {
    // Zod schema for parameters
    param1: z.string().describe("Description of parameter"),
    param2: z.number().optional().describe("Optional parameter"),
  },
  async ({ param1, param2 }) => {
    // Your tool logic here
    return {
      content: [
        {
          type: "text",
          text: "Your response",
        },
      ],
    };
  }
);

Adding Resources

Resources provide dynamic content that the AI can access:

server.resource(
  "resource://example/{id}",
  "Description of the resource",
  async (uri) => {
    // Extract parameters from URI
    const id = uri.path.split("/").pop();

    return {
      contents: [
        {
          uri,
          mimeType: "text/plain",
          text: `Content for ${id}`,
        },
      ],
    };
  }
);

Adding Prompts

Prompts are reusable templates:

server.prompt(
  "prompt-name",
  "Description of the prompt",
  {
    // Parameters for the prompt
    topic: z.string().describe("The topic to discuss"),
  },
  async ({ topic }) => {
    return {
      description: `A prompt about ${topic}`,
      messages: [
        {
          role: "user",
          content: {
            type: "text",
            text: `Please help me with ${topic}`,
          },
        },
      ],
    };
  }
);

Project Structure

├── src/
│   └── index.ts              # Main MCP server implementation
├── scripts/
│   ├── update-config.js      # Multi-client configuration installer
│   └── build-and-publish.js  # Automated npm publishing workflow
├── dist/                     # Compiled JavaScript (generated)
├── package.json              # Project configuration
├── tsconfig.json             # TypeScript configuration
├── CLAUDE.md                 # Claude Code instructions
├── .env.local                # Environment variables (optional)
└── README.md                 # This file

Development Workflow

Local Development

Make changes to src/index.ts
Run pnpm run build to compile TypeScript
Test your server with pnpm start
Use pnpm run install-mcp for local testing
Restart your MCP client to load changes

Publishing Updates

Test your changes locally
Run pnpm run release to publish to npm
Clients using npx @r-mcp/<your-package>@latest auto-update
No client reconfiguration needed

Environment Variables

Create a .env.local file for environment-specific configuration:

# .env.local
API_KEY=your-api-key
DATABASE_URL=your-database-url

These variables are automatically included in MCP server configurations during installation.

Next Steps

Fork or clone this boilerplate
Customize the server name and tools in src/index.ts
Add your own tools, resources, and prompts
Configure environment variables in .env.local
Run pnpm run release to publish your server
Install to clients with pnpm run install-server

License

MIT

Available Tools

7 tools

mongo-aggregateC

Execute aggregation pipeline on a MongoDB collection

ParametersJSON Schema

Name	Required	Description
`database`	Yes	Database name
`collection`	Yes	Collection name
`pipeline`	Yes	Aggregation pipeline as array of stage objects

TDQS

C2.9/5.0

Behavior2/5

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

No annotations are provided, so the description carries full burden. It mentions 'Execute aggregation pipeline' which implies a read operation, but doesn't disclose if it's read-only, has side effects, requires specific permissions, or handles errors. For a tool with no annotations, this leaves critical behavioral traits unspecified.

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?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place without redundancy.

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 no annotations, no output schema, and a tool that performs complex database operations, the description is incomplete. It doesn't explain return values, error handling, or performance implications. For a tool with 3 parameters and significant behavioral complexity, this minimal description leaves too many gaps for effective use.

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 the schema already documents all parameters (database, collection, pipeline). The description adds no additional meaning beyond what's in the schema, such as explaining what an aggregation pipeline is or providing usage examples. Baseline 3 is appropriate when schema does the heavy lifting.

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 action ('Execute aggregation pipeline') and resource ('on a MongoDB collection'), making the purpose understandable. However, it doesn't differentiate from sibling tools like mongo-find-documents or mongo-count-documents, which also operate on collections but with different query methods.

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. With siblings like mongo-find-documents for simple queries and mongo-count-documents for counting, there's no indication that this tool is for complex data transformations or analytics, leaving the agent to guess based on the name alone.

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

mongo-count-documentsC

Count documents in a MongoDB collection

ParametersJSON Schema

Name	Required	Description
`database`	Yes	Database name
`collection`	Yes	Collection name
`filter`	No	Query filter as JSON object (optional)

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 but provides minimal information. It doesn't mention performance characteristics (e.g., whether this uses MongoDB's countDocuments method vs estimatedDocumentCount), whether it requires specific permissions, or what happens with large collections. The description states what the tool does but not how it behaves.

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?

The description is perfectly concise at just 6 words - every word earns its place. It's front-loaded with the core functionality and wastes no space on unnecessary elaboration. This is an excellent example of efficient communication.

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 database query tool with 3 parameters (including a complex filter object) and no annotations or output schema, the description is insufficient. It doesn't explain what the tool returns (just a number? metadata?), how errors are handled, or provide any context about the filter parameter's capabilities beyond what's in the schema. The description should do more to compensate for the lack of structured metadata.

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 description mentions 'documents in a MongoDB collection' which implies the need for database and collection parameters, but adds no semantic value beyond what the 100% schema coverage already provides. The schema already documents all three parameters clearly, so the description doesn't enhance understanding of what each parameter means or how they interact.

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 resource ('documents in a MongoDB collection'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'mongo-find-documents' or 'mongo-aggregate' which could also provide count information through different mechanisms.

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. With siblings like 'mongo-find-documents' (which could count by returning array length) and 'mongo-aggregate' (which could include count operations), there's no indication of when this specialized count tool is preferred or what its performance characteristics might be.

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

mongo-create-documentC

Create a new document in a MongoDB collection

ParametersJSON Schema

Name	Required	Description
`database`	Yes	Database name
`collection`	Yes	Collection name
`document`	Yes	Document to insert as JSON object

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 the full burden of behavioral disclosure. It states the tool creates a document but doesn't mention whether this requires specific permissions, how errors are handled (e.g., duplicate keys), what the return value looks like, or any side effects. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly, earning full marks for conciseness.

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 the tool's complexity (a write operation with 3 parameters and no output schema) and lack of annotations, the description is insufficient. It doesn't explain what happens after creation (e.g., returns an ID), error handling, or how it differs from sibling tools, leaving critical gaps for an agent to understand the full context.

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 description adds no parameter-specific information beyond what's already in the schema, which has 100% coverage with clear descriptions for 'database', 'collection', and 'document'. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate with additional semantic context.

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 action ('Create a new document') and resource ('in a MongoDB collection'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its siblings like 'mongo-update-document' or 'mongo-delete-document' beyond the basic verb difference, missing explicit differentiation.

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 like 'mongo-update-document' for modifying existing documents or 'mongo-find-documents' for reading. There's no mention of prerequisites, error conditions, or typical use cases, leaving the agent with minimal contextual direction.

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

mongo-delete-documentC

Delete documents from a MongoDB collection

ParametersJSON Schema

Name	Required	Description
`database`	Yes	Database name
`collection`	Yes	Collection name
`filter`	Yes	Query filter to match documents to delete
`deleteMany`	No	Whether to delete multiple documents (default: false)

TDQS

C2.9/5.0

Behavior2/5

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

No annotations are provided, so the description carries full burden. It states 'Delete documents' which implies a destructive mutation, but doesn't disclose critical behaviors: whether deletion is permanent, if it requires specific permissions, what happens on empty filter matches, or error handling. For a destructive tool with zero annotation coverage, this is a significant gap in safety and operational context.

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?

The description is a single, direct sentence with zero wasted words. It's front-loaded with the core action and resource, making it highly efficient. Every word earns its place by conveying essential purpose without redundancy.

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 this is a destructive tool with no annotations and no output schema, the description is incomplete. It lacks behavioral context (e.g., permanence, permissions), usage guidelines, and output expectations. While the schema covers parameters well, the overall context for safe and effective use is insufficient.

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 the schema fully documents all 4 parameters (database, collection, filter, deleteMany). The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain filter syntax, default behaviors, or provide examples. Baseline 3 is appropriate when the schema does all the heavy lifting.

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 action ('Delete') and resource ('documents from a MongoDB collection'), making the purpose immediately understandable. It distinguishes this as a deletion tool among siblings like create, find, update, and aggregate. However, it doesn't specify whether it deletes one or many documents by default, which could be more precise.

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. It doesn't mention prerequisites like database/collection existence, compare with mongo-update-document for modifications, or warn about irreversible deletion. The agent must infer usage from the tool name and context alone.

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

mongo-find-documentsC

Query documents from a MongoDB collection

ParametersJSON Schema

Name	Required	Description
`database`	Yes	Database name
`collection`	Yes	Collection name
`filter`	No	Query filter as JSON object (optional)
`limit`	No	Maximum number of documents to return (optional)

TDQS

C2.9/5.0

Behavior2/5

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Query') but doesn't cover critical aspects like read-only nature (implied but not explicit), potential performance impacts, error handling, or return format. This is inadequate for a tool with database operations.

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?

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse without unnecessary elaboration.

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 the complexity of a database query tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., read-only, error cases), return values, or how it differs from siblings, leaving significant gaps for an AI agent to operate effectively.

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 the input schema fully documents all parameters (database, collection, filter, limit). The description adds no additional meaning beyond what the schema provides, such as examples or usage tips for the filter parameter. Baseline 3 is appropriate when the schema handles parameter documentation.

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 'Query documents from a MongoDB collection' clearly states the verb ('Query') and resource ('documents from a MongoDB collection'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like mongo-aggregate or mongo-count-documents, which also involve querying operations, so it misses full sibling distinction.

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. With siblings like mongo-aggregate for complex queries and mongo-count-documents for counting, there's no mention of context, prerequisites, or exclusions, leaving the agent to guess based on tool names alone.

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

mongo-list-collectionsB

List all collections in a MongoDB database

ParametersJSON Schema

Name	Required	Description	Default
`database`	Yes	Database name

TDQS

B3.1/5.0

Behavior2/5

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states a read operation ('List'), implying it's non-destructive, but doesn't cover aspects like permissions needed, rate limits, error conditions, or what the output looks like (e.g., format, pagination). This leaves significant gaps for a tool that interacts with a database.

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?

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded and wastes no space, making it easy for an agent to parse quickly.

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

Completeness3/5

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

Given the tool's low complexity (one parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on behavior, usage context, and output, which could be important for database operations. This aligns with a score of 3, indicating clear gaps in completeness despite the simple structure.

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% description coverage, with the 'database' parameter clearly documented. The description adds no additional meaning beyond the schema, such as examples or constraints (e.g., database must exist). This meets the baseline score of 3, as the schema adequately covers parameter semantics without extra value from the description.

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 action ('List all collections') and resource ('in a MongoDB database'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'mongo-find-documents' or 'mongo-aggregate', which operate on documents rather than collections, leaving some room for improvement in sibling distinction.

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. It lacks context about prerequisites (e.g., database existence), exclusions, or comparisons to siblings like 'mongo-find-documents' for document-level operations, leaving the agent to infer usage based on tool names alone.

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

mongo-update-documentC

Update documents in a MongoDB collection

ParametersJSON Schema

Name	Required	Description
`database`	Yes	Database name
`collection`	Yes	Collection name
`filter`	Yes	Query filter to match documents to update
`update`	Yes	Update operations as JSON object
`updateMany`	No	Whether to update multiple documents (default: false)

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 the full burden of behavioral disclosure. It states the action is an update but doesn't cover critical aspects like whether it's destructive, what permissions are needed, how errors are handled, or the response format. This is a significant gap for a mutation tool with complex parameters.

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?

The description is a single, efficient sentence that directly states the tool's purpose without any fluff. It's front-loaded and wastes no words, making it easy for an agent to parse quickly.

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 the complexity of a MongoDB update operation with 5 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on behavior, error handling, return values, and how to use parameters effectively, making it incomplete for safe and accurate tool invocation.

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 description doesn't add any parameter-specific information beyond what's already in the schema, which has 100% coverage. It mentions 'documents' and 'collection' but doesn't explain the semantics of filter, update, or updateMany. The baseline score of 3 reflects adequate but minimal value added over the schema.

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 action ('Update') and resource ('documents in a MongoDB collection'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like mongo-create-document or mongo-delete-document beyond the verb 'Update', which is why it doesn't reach a perfect score.

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. It doesn't mention prerequisites, when to choose update over create/delete, or how it relates to siblings like mongo-aggregate or mongo-find-documents, 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.

Tool Schema Changelog

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

7 tool updatesv1.0.0Jan 3, 2026
- Changedmongo-aggregate2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedmongo-count-documents2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedmongo-create-document2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedmongo-delete-document2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedmongo-find-documents2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedmongo-list-collections2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
- Changedmongo-update-document2 fields changed
  - addedInput schema / $schema
```
Added value: +"http://json-schema.org/draft-07/schema#"
```
  - addedInput schema / additionalProperties
```
Added value: +false
```
7 tool updatesOct 1, 2025
- First observedmongo-aggregate
- First observedmongo-count-documents
- First observedmongo-create-document
- First observedmongo-delete-document
- First observedmongo-find-documents
- First observedmongo-list-collections
- First observedmongo-update-document

Install Server

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

TDQS

A3.5/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose targeting specific MongoDB operations with no overlap. The descriptions precisely differentiate between aggregation, counting, creating, deleting, finding, listing collections, and updating documents, making misselection unlikely.

Naming Consistency5/5

All tools follow a consistent 'mongo-verb-document/collection' pattern using kebab-case throughout. This predictable naming scheme (e.g., mongo-create-document, mongo-list-collections) enhances readability and agent usability.

Tool Count5/5

With 7 tools, this server is well-scoped for MongoDB operations, covering essential CRUD and utility functions. Each tool earns its place without redundancy, and the count is typical for a focused database server.

Completeness5/5

The toolset provides complete coverage for MongoDB interactions, including create, read (find/count), update, delete, aggregation, and collection listing. There are no obvious gaps, enabling agents to handle full document lifecycle and database management tasks.

Maintenance

ActivityInactive

ResponsivenessNo issues

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

Remote Desktop CommanderOAuth
app.desktopcommander
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
Shell Access OS Automation
214
driflyte-mcp-server
com.driflyte
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
Search Web Scraping Knowledge & Memory
211
gread A
io.github.NitroRCr
An MCP server that gives your AI access to the source code and docs of all public github repos
Version Control Code Analysis Documentation Access
5361
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

Related MCP Servers

MCP Server Boilerplate
luquitared
F
license
C
quality
D
maintenance
A starter template for building MCP servers that can integrate with Claude, Cursor, or other MCP-compatible AI assistants to create custom tools, resource providers, and prompt templates.
Updated a year ago (2025-07-25 00:04 UTC)
2
8
-
MCP Server Boilerplate
Developer Tools App Automation
BoosClues
F
license
C
quality
D
maintenance
A starter template for building custom MCP servers that can integrate with Claude Desktop, Cursor, and other AI assistants. Provides example tools, TypeScript support, and automated publishing workflow to help developers create their own tools and resource providers.
Updated a year ago (2025-09-12 22:58 UTC)
2
20
-
MCP Server Boilerplate
Developer Tools
ricleedo
F
license
B
quality
D
maintenance
A starter template for building custom MCP servers that can integrate with Claude Desktop, Cursor, and other AI assistants. Provides example tools, TypeScript support, and automated publishing workflows to help developers quickly create their own MCP integrations.
Updated a year ago (2025-10-02 00:45 UTC)
1
12
-
MCP Server Boilerplate
Developer Tools
ricleedo
F
license
A
quality
D
maintenance
A starter template for building custom MCP servers that can integrate with Claude Desktop, Cursor, and other AI assistants. Provides example tools, TypeScript support, and automated publishing workflows to help developers quickly create their own MCP servers.
Updated a year ago (2025-10-02 01:02 UTC)
7
11
-

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/CaptainCrouton89/mongo-mcp'

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

MCP Server Boilerplate

Purpose

Features

How It Works

Getting Started

Option 1: Use the Published Package (Recommended)

Option 2: Customize and Develop

Installation Scripts

Publishing Your Server

Usage with MCP Clients

Production Clients (Claude Desktop, Cursor, Claude Code, Gemini):

Local Development (.mcp.json):

Customizing Your Server

Adding Tools

Adding Resources

Adding Prompts

Project Structure

Development Workflow

Local Development

Publishing Updates

Environment Variables

Next Steps

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

Local Development (`.mcp.json`):