docs: list all available tools with a generate script MCP-340

Author: gagik

README.md

@@ -283,49 +283,54 @@ npx -y mongodb-mcp-server@latest --transport http --httpHost=0.0.0.0 --httpPort=
 
 #### MongoDB Atlas Tools
 
-- `atlas-list-orgs` - Lists MongoDB Atlas organizations
-- `atlas-list-projects` - Lists MongoDB Atlas projects
-- `atlas-create-project` - Creates a new MongoDB Atlas project
-- `atlas-list-clusters` - Lists MongoDB Atlas clusters
-- `atlas-inspect-cluster` - Inspect a specific MongoDB Atlas cluster
+- `atlas-connect-cluster` - Connect to MongoDB Atlas cluster
+- `atlas-create-access-list` - Allow Ip/CIDR ranges to access your MongoDB Atlas clusters.
+- `atlas-create-db-user` - Create an MongoDB Atlas database user
 - `atlas-create-free-cluster` - Create a free MongoDB Atlas cluster
-- `atlas-connect-cluster` - Connects to MongoDB Atlas cluster
-- `atlas-inspect-access-list` - Inspect IP/CIDR ranges with access to MongoDB Atlas clusters
-- `atlas-create-access-list` - Configure IP/CIDR access list for MongoDB Atlas clusters
+- `atlas-create-project` - Create a MongoDB Atlas project
+- `atlas-get-performance-advisor` - Get MongoDB Atlas performance advisor recommendations, which includes the operations: suggested indexes, drop index suggestions, schema suggestions, and a sample of the most recent (max 50) slow query logs
+- `atlas-inspect-access-list` - Inspect Ip/CIDR ranges with access to your MongoDB Atlas clusters.
+- `atlas-inspect-cluster` - Inspect MongoDB Atlas cluster
+- `atlas-list-alerts` - List MongoDB Atlas alerts
+- `atlas-list-clusters` - List MongoDB Atlas clusters
 - `atlas-list-db-users` - List MongoDB Atlas database users
-- `atlas-create-db-user` - Creates a MongoDB Atlas database user
-- `atlas-list-alerts` - List MongoDB Atlas Alerts for a Project
-- `atlas-get-performance-advisor` - Gets Atlas Performance Advisor recommendations (index suggestions, drop index suggestions, schema suggestions, slow query logs)
+- `atlas-list-orgs` - List MongoDB Atlas organizations
+- `atlas-list-projects` - List MongoDB Atlas projects
 
 NOTE: atlas tools are only available when you set credentials on [configuration](#configuration) section.
 
 #### MongoDB Atlas Local Tools
 
-- `atlas-local-list-deployments` - Lists MongoDB Atlas Local deployments
-- `atlas-local-create-deployment` - Creates a MongoDB Atlas Local deployment
-- `atlas-local-connect-deployment` - Connects to a MongoDB Atlas Local deployment
-- `atlas-local-delete-deployment` - Deletes a MongoDB Atlas Local deployment
+- `atlas-local-connect-deployment` - Connect to a MongoDB Atlas Local deployment
+- `atlas-local-create-deployment` - Create a MongoDB Atlas local deployment
+- `atlas-local-delete-deployment` - Delete a MongoDB Atlas local deployment
+- `atlas-local-list-deployments` - List MongoDB Atlas local deployments
 
 #### MongoDB Database Tools
 
-- `connect` - Connect to a MongoDB instance
-- `find` - Run a find query against a MongoDB collection. The number of documents returned is limited by the `limit` parameter and the server's `maxDocumentsPerQuery` configuration, whichever is smaller. The total size of the returned documents is also limited by the `responseBytesLimit` parameter and the server's `maxBytesPerQuery` configuration, whichever is smaller.
-- `aggregate` - Run an aggregation against a MongoDB collection. The number of documents returned is limited by the server's `maxDocumentsPerQuery` configuration. The total size of the returned documents is also limited by the `responseBytesLimit` parameter and the server's `maxBytesPerQuery` configuration, whichever is smaller.
-- `count` - Get the number of documents in a MongoDB collection
-- `insert-many` - Insert multiple documents into a MongoDB collection
-- `create-index` - Create an index for a MongoDB collection
-- `update-many` - Update multiple documents in a MongoDB collection
-- `rename-collection` - Rename a MongoDB collection
-- `delete-many` - Delete multiple documents from a MongoDB collection
-- `drop-collection` - Remove a collection from a MongoDB database
-- `drop-database` - Remove a MongoDB database
-- `list-databases` - List all databases for a MongoDB connection
-- `list-collections` - List all collections for a given database
+- `aggregate` - Run an aggregation against a MongoDB collection
 - `collection-indexes` - Describe the indexes for a collection
 - `collection-schema` - Describe the schema for a collection
-- `collection-storage-size` - Get the size of a collection in MB
-- `db-stats` - Return statistics about a MongoDB database
-- `export` - Export query or aggregation results to EJSON format. Creates a uniquely named export accessible via the `exported-data` resource.
+- `collection-storage-size` - Gets the size of the collection
+- `connect` - Connect to a MongoDB instance
+- `count` - Gets the number of documents in a MongoDB collection using db.collection.count() and query as an optional filter parameter
+- `create-collection` - Creates a new collection in a database. If the database doesn't exist, it will be created automatically.
+- `create-index` - Create an index for a collection
+- `db-stats` - Returns statistics that reflect the use state of a single database
+- `delete-many` - Removes all documents that match the filter from a MongoDB collection
+- `drop-collection` - Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection.
+- `drop-database` - Removes the specified database, deleting the associated data files
+- `drop-index` - Drop an index for the provided database and collection.
+- `explain` - Returns statistics describing the execution of the winning plan chosen by the query optimizer for the evaluated method
+- `export` - Export a query or aggregation results in the specified EJSON format.
+- `find` - Run a find query against a MongoDB collection
+- `insert-many` - Insert an array of documents into a MongoDB collection
+- `list-collections` - List all collections for a given database
+- `list-databases` - List all databases for a MongoDB connection
+- `mongodb-logs` - Returns the most recent logged mongod events
+- `rename-collection` - Renames a collection in a MongoDB database
+- `switch-connection` - Switch to a different MongoDB connection
+- `update-many` - Updates all documents that match the specified filter for a collection
 
 ## 📄 Supported Resources
 

package.json

@@ -65,7 +65,7 @@
     "reformat": "prettier --write .",
     "generate": "pnpm run generate:api && pnpm run generate:arguments",
     "generate:api": "./scripts/generate.sh",
-    "generate:arguments": "tsx scripts/generateArguments.ts",
+    "generate:arguments": "tsx scripts/generate/index.ts",
     "pretest": "pnpm run build",
     "test": "vitest --project eslint-rules --project unit-and-integration --coverage --run",
     "test:accuracy": "sh ./scripts/accuracy/runAccuracyTests.sh",

scripts/generate/README.md

@@ -0,0 +1,17 @@
+# Generate Scripts
+
+This folder contains a helper script which generates various documentation and configurations based on our code.
+
+## Files
+
+- **`index.ts`** - Main entry point that orchestrates all generation tasks
+- **`generateArguments.ts`** - Generates CLI arguments, environment variables, and configuration tables from the UserConfig Zod Schema
+- **`generateToolDocumentation.ts`** - Generates tool documentation by reading from the AllTools array
+
+## Usage
+
+Run all generators:
+
+```bash
+pnpm run generate:arguments
+```

scripts/generateArguments.ts scripts/generate/generateArguments.tsscripts/generateArguments.ts renamed to scripts/generate/generateArguments.ts

@@ -1,5 +1,3 @@
-#!/usr/bin/env tsx
-
 /**
  * This script generates argument definitions and updates:
  * - server.json arrays
@@ -11,7 +9,7 @@
 import { readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-import { UserConfigSchema, configRegistry } from "../src/common/config/userConfig.js";
+import { UserConfigSchema, configRegistry } from "../../src/common/config/userConfig.js";
 import { execSync } from "child_process";
 import type { z as z4 } from "zod/v4";
 
@@ -205,8 +203,8 @@ function generatePackageArguments(envVars: ArgumentInfo[]): unknown[] {
 }
 
 function updateServerJsonEnvVars(envVars: ArgumentInfo[]): void {
-    const serverJsonPath = join(__dirname, "..", "server.json");
-    const packageJsonPath = join(__dirname, "..", "package.json");
+    const serverJsonPath = join(__dirname, "..", "..", "server.json");
+    const packageJsonPath = join(__dirname, "..", "..", "package.json");
 
     const content = readFileSync(serverJsonPath, "utf-8");
     const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as { version: string };
@@ -310,7 +308,7 @@ function generateReadmeConfigTable(argumentInfos: ArgumentInfo[]): string {
 }
 
 function updateReadmeConfigTable(envVars: ArgumentInfo[]): void {
-    const readmePath = join(__dirname, "..", "README.md");
+    const readmePath = join(__dirname, "..", "..", "README.md");
     let content = readFileSync(readmePath, "utf-8");
 
     const newTable = generateReadmeConfigTable(envVars);
@@ -325,15 +323,13 @@ function updateReadmeConfigTable(envVars: ArgumentInfo[]): void {
     console.log("✓ Updated README.md configuration table");
 
     // Run prettier on the README.md file
-    execSync("npx prettier --write README.md", { cwd: join(__dirname, "..") });
+    execSync("npx prettier --write README.md", { cwd: join(__dirname, "..", "..") });
 }
 
-function main(): void {
+export function generateArguments(): void {
     const zodMetadata = extractZodDescriptions();
-
     const argumentInfo = getArgumentInfo(zodMetadata);
     updateServerJsonEnvVars(argumentInfo);
     updateReadmeConfigTable(argumentInfo);
 }
 
-main();

scripts/generate/generateToolDocumentation.ts

@@ -0,0 +1,149 @@
+/**
+ * This script generates tool documentation and updates:
+ * - README.md tools list
+ *
+ * It uses the AllTools array from the tools module.
+ */
+
+import { readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { AllTools } from "../../src/tools/index.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+interface ToolInfo {
+    name: string;
+    description: string;
+    category: string;
+    operationType: string;
+}
+
+const overrides: Record<string, string> = {
+    connect: "Connect to a MongoDB instance",
+    "switch-connection": "Switch to a different MongoDB connection",
+};
+
+function extractToolInformation(): ToolInfo[] {
+    const tools: ToolInfo[] = [];
+
+    for (const ToolClass of AllTools) {
+        // Create a minimal instance to access instance properties
+        // We need to provide dummy params since we only need name and description
+        const dummyParams = {
+            category: ToolClass.category,
+            operationType: ToolClass.operationType,
+            session: {
+                on: () => {},
+                off: () => {},
+                emit: () => false,
+                connectionManager: null,
+            } as never,
+            config: {
+                previewFeatures: [],
+                vectorSearchDimensions: 1024,
+                vectorSearchModel: "voyage-3-large",
+                readOnly: false,
+                disabledTools: [],
+            } as never,
+            telemetry: {
+                emitEvents: () => {},
+            } as never,
+            elicitation: {
+                requestConfirmation: () => Promise.resolve(false),
+            } as never,
+        };
+
+        try {
+            const instance = new ToolClass(dummyParams);
+            // Access the protected description property
+            const description =
+                (instance as unknown as { description?: string }).description || "No description available";
+            tools.push({
+                name: instance.name,
+                description: overrides[instance.name] || description,
+                category: ToolClass.category,
+                operationType: ToolClass.operationType,
+            });
+        } catch (error) {
+            console.error(`Error instantiating tool ${ToolClass.name}:`, error);
+        }
+    }
+
+    // Sort by category first, then by name
+    return tools.sort((a, b) => {
+        if (a.category !== b.category) {
+            return a.category.localeCompare(b.category);
+        }
+        return a.name.localeCompare(b.name);
+    });
+}
+
+function generateReadmeToolsList(tools: ToolInfo[]): string {
+    const sections: string[] = [];
+
+    // Group tools by category
+    const toolsByCategory: Record<string, ToolInfo[]> = {};
+    for (const tool of tools) {
+        if (!toolsByCategory[tool.category]) {
+            toolsByCategory[tool.category] = [];
+        }
+        const categoryTools = toolsByCategory[tool.category];
+        if (categoryTools) {
+            categoryTools.push(tool);
+        }
+    }
+
+    // Generate sections for each category
+    const categoryTitles: Record<string, string> = {
+        atlas: "MongoDB Atlas Tools",
+        "atlas-local": "MongoDB Atlas Local Tools",
+        mongodb: "MongoDB Database Tools",
+    };
+
+    const categoryOrder = ["atlas", "atlas-local", "mongodb"];
+
+    for (const category of categoryOrder) {
+        if (!toolsByCategory[category]) continue;
+
+        sections.push(`#### ${categoryTitles[category]}\n`);
+
+        for (const tool of toolsByCategory[category]) {
+            sections.push(`- \`${tool.name}\` - ${tool.description}`);
+        }
+
+        // Add note for Atlas tools
+        if (category === "atlas") {
+            sections.push(
+                "\nNOTE: atlas tools are only available when you set credentials on [configuration](#configuration) section.\n"
+            );
+        } else {
+            sections.push("");
+        }
+    }
+
+    return sections.join("\n");
+}
+
+function updateReadmeToolsList(tools: ToolInfo[]): void {
+    const readmePath = join(__dirname, "..", "..", "README.md");
+    let content = readFileSync(readmePath, "utf-8");
+
+    const newToolsList = generateReadmeToolsList(tools);
+
+    // Find and replace the tools list section
+    // Match from "### Tool List" to the next "## " section
+    const toolsRegex = /### Tool List\n\n([\s\S]*?)\n\n## 📄 Supported Resources/;
+    const replacement = `### Tool List\n\n${newToolsList}\n## 📄 Supported Resources`;
+
+    content = content.replace(toolsRegex, replacement);
+
+    writeFileSync(readmePath, content, "utf-8");
+    console.log("✓ Updated README.md tools list");
+}
+
+export function generateToolDocumentation(): void {
+    const toolInfo = extractToolInformation();
+    updateReadmeToolsList(toolInfo);
+}

scripts/generate/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env tsx
+
+/**
+ * Main script that generates all documentation and configuration files:
+ * - CLI arguments and configuration tables
+ * - Tool documentation
+ */
+
+import { generateArguments } from "./generateArguments.js";
+import { generateToolDocumentation } from "./generateToolDocumentation.js";
+
+function main(): void {
+    console.log("Generating arguments and configuration...");
+    generateArguments();
+
+    console.log("\nGenerating tool documentation...");
+    generateToolDocumentation();
+
+    console.log("\n✅ All documentation generated successfully!");
+}
+
+main();

tsconfig.build.json

@@ -20,7 +20,8 @@
     "declarationMap": true,
     "paths": {
       "mongodb-connection-string-url": [
-        "./node_modules/mongodb-connection-string-url/lib/index.d.ts"
+        "./node_modules/mongodb-connection-string-url/lib/index.js",
+        "./node_modules/mongodb-connection-string-url/lib/index.d.js"
       ],
       "ts-levenshtein": ["./node_modules/ts-levenshtein/dist/index.d.mts"]
     }