Uses environment variables for configuration of API endpoints and service connections
Provides AI-powered image generation using the flux.1-kontext-pro model for high-quality artistic content creation
Enables execution of Git commands through whitelisted CLI command functionality for repository management
Built on Node.js runtime environment for server execution and package management
Supports npm command execution through CLI tools and uses npm for dependency management
Integrates with OpenAI's DALL-E (gpt-image-1 model) for AI-powered image generation and editing capabilities
Uses ts-node for TypeScript development and runtime execution during development
Implemented in TypeScript using the official MCP TypeScript SDK for type-safe server development
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Multi-Feature MCP Server generate an image of a sunset over mountains"
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.
This project is a Model Context Protocol (MCP) server implemented using Node.js and TypeScript, following the official MCP TypeScript SDK.
It provides multiple capabilities including weather data, system utilities, Azure integration, and AI-powered image generation and editing.
Current Weather: Get the current weather for any city
Weather Forecast: Get a 3-day weather forecast for any city
City Search: Find cities by name
CLI Commands: Execute safe, whitelisted CLI commands
Directory Listing: List files and directories
System Info: Get basic system information
Azure Integration: Manage Azure subscriptions and resource groups with MCP elicitation
Azure Storage: Manage Azure Storage blobs and containers
Image Generation: Generate images using AI models (gpt-image-1, flux.1-kontext-pro)
Image Editing: Edit existing images with AI-powered modifications and enhancements
Related MCP server: FastMCP Multi-Tool Server
Node.js v18.x or higher
npm installCopy the sample environment file:
cp .env.sample .envEdit .env file to configure your image API endpoints:
GENERATE_IMAGE_API_URL=http://127.0.0.1:8000/v1/images/generations
EDIT_IMAGE_API_URL=http://127.0.0.1:8000/v1/images/editsnpx tscnpx ts-node src/server.tsnpm run startsrc/server.ts: Main MCP server implementation
package.json: Project configuration and dependencies
tsconfig.json: TypeScript configuration
.env: Environment configuration (create from .env.sample)
.env.sample: Environment configuration template
.gitignore: Git ignore rules
You can use these prompts with an MCP-compatible client or extension:
Get current weather
currentWeather: city = Seattle
What is the current weather in Paris?
weather in Phoenix
Get weather forecast
forecast: city = New York
weather forecast for Seattle
3-day forecast for London
Search for a city
searchCity: query = Washington
Find cities named "Springfield"
Execute CLI commands
executeCommand: command = "git status"
executeCommand: command = "ls -la"
executeCommand: command = "npm --version"
List directory contents
listDirectory: path = "."
listDirectory: path = "src"
Get system information
getSystemInfo
Azure subscription management
listAzureSubscriptions
getCurrentAzureSubscription
Azure resource groups (with MCP elicitation)
listAzureResourceGroups (uses VS Code command palette for subscription selection)
Image generation
generateImages: prompt = "A futuristic cityscape at sunset"
generateImages: prompt = "A cute robot", model = "flux.1-kontext-pro", size = "512x512", quality = "hd"
generateImages: prompt = "Mountain landscape", model = "gpt-image-1", n = 2
Image editing
editImages: prompt = "Add a rainbow in the sky", image = "<base64-data>"
editImages: prompt = "Change the car color to red", image = "<base64-data>", model = "gpt-image-1"
editImages: prompt = "Remove the background", image = "<base64-data>", quality = "hd"
Create a .env file in the project root (copy from .env.sample):
# Image Generation API Configuration
GENERATE_IMAGE_API_URL=http://127.0.0.1:8000/v1/images/generations
# Image Editing API Configuration
EDIT_IMAGE_API_URL=http://127.0.0.1:8000/v1/images/editsNote: You can configure separate endpoints for generation and editing to work with different services.
The image generation tools require running API servers with the following endpoints:
POST /v1/images/generations - Generate images from text prompts (configured via GENERATE_IMAGE_API_URL)
POST /v1/images/edits - Edit images with AI modifications (configured via EDIT_IMAGE_API_URL)
Supported Models:
gpt-image-1 (Azure OpenAI DALL-E) - Default model
flux.1-kontext-pro (Flux model) - High-quality artistic generation
Model-Specific Features:
gpt-image-1: Quality options (standard, hd), supports both generation and editing
flux.1-kontext-pro: Standard quality only, optimized for creative content
Supported Sizes: 1024x1024 (default), 512x512, 256x256, and other standard dimensions Quality Options:
gpt-image-1: standard, hd
flux.1-kontext-pro: standard
This server demonstrates proper implementation of the MCP Elicitation specification with VS Code integration:
listAzureResourceGroups ToolInteractive Selection: When called without a subscriptionId parameter, triggers the VS Code MCP extension's command palette
Native Integration: Uses the official MCP elicitation protocol (elicitation/create JSON-RPC request)
Rich UI: Shows subscription names with "(ACTIVE)" indicator in the selection dropdown
Enum Schema: Provides structured choices with display names for better UX
How it works:
Tool is called without subscriptionId parameter
Server sends elicitation/create request to client
VS Code MCP extension shows command palette with subscription options
User selects subscription from dropdown
Tool continues with selected subscription ID
This showcases the proper way to implement interactive, user-driven parameter selection in MCP servers.
Get the current weather for a city
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes |
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 but offers minimal insight. It implies a read-only operation ('Get') but doesn't cover critical aspects like error handling for invalid cities, data sources, rate limits, or response format. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, consisting of a single, clear sentence that directly states the tool's function. There is no wasted language or unnecessary elaboration, making it efficient for quick comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema, no annotations), the description is incomplete. It doesn't address key contextual elements like what weather data is returned (e.g., temperature, conditions), error scenarios, or how it differs from sibling tools. This makes it inadequate for reliable agent operation without additional assumptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate but fails to add meaningful parameter details. It mentions 'city' as the parameter but doesn't specify format (e.g., city name, coordinates), examples, or constraints (e.g., must be a valid city from a supported list). This leaves the single required parameter poorly defined for effective use.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('current weather for a city'), making it immediately understandable. However, it doesn't distinguish itself from its sibling 'forecast', which likely provides future weather predictions, leaving room for potential confusion between current vs. forecasted weather queries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 the sibling 'forecast' tool for future weather or 'searchCity' for city lookups, nor does it specify prerequisites like needing a valid city name. This lack of context could lead to misuse or redundant tool calls.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Edit Images
| Name | Required | Description | Default |
|---|---|---|---|
| image | Yes | Base64-encoded image data | |
| model | No | Model to use for editing | gpt-image-1 |
| n | No | Number of images to generate | |
| prompt | Yes | How to edit the image | |
| quality | No | Image quality | |
| size | No | Image size | 1024x1024 |
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 but fails completely. It doesn't indicate whether this is a read or write operation, what permissions might be required, whether it's destructive, what rate limits apply, or what the expected output format might be. The description adds zero behavioral context beyond the vague implication of 'editing.'
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While technically concise with only two words, this represents under-specification rather than effective brevity. The description fails to provide any useful information that would help an AI agent understand or use the tool. Every word should earn its place, but here the words provide no value beyond the tool name itself.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a complex image editing tool with 6 parameters, no annotations, and no output schema, the description is completely inadequate. It provides no information about what the tool does, how it behaves, what it returns, or when to use it. The description fails to compensate for the lack of annotations and output schema documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 6 parameters thoroughly. The description adds no additional semantic information about parameters beyond what's in the schema. The baseline score of 3 reflects adequate parameter documentation through the schema alone, though the description contributes nothing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tautological: description restates name/title.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides absolutely no guidance about when to use this tool versus alternatives. There's no mention of appropriate contexts, prerequisites, or comparisons to sibling tools like 'generateImages' that might serve similar purposes. Users must infer everything from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a whitelisted CLI command safely
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes |
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 mentions 'whitelisted' and 'safely,' hinting at security constraints, but fails to detail critical traits such as permission requirements, rate limits, error handling, or what 'safely' entails. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single, front-loaded sentence: 'Execute a whitelisted CLI command safely.' Every word earns its place by conveying the core action and key constraints without waste, making it efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (executing CLI commands), lack of annotations, no output schema, and poor parameter coverage, the description is incomplete. It omits essential details like return values, error conditions, and operational limits, leaving the agent with insufficient context for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the tool description does not add any meaning beyond the schema. It does not explain what the 'command' parameter expects (e.g., format, examples, or whitelist specifics), failing to compensate for the lack of schema documentation. This results in poor parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool 'Execute[s] a whitelisted CLI command safely,' which provides a verb ('Execute') and resource ('CLI command') but is vague about scope and constraints. It does not clearly differentiate from siblings like 'listDirectory' or 'getSystemInfo,' which might also involve CLI operations, leaving the purpose somewhat ambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. The description mentions 'whitelisted' and 'safely,' implying some restrictions, but does not specify contexts, prerequisites, or exclusions. Without explicit when/when-not instructions, users may struggle to choose this over sibling tools like 'listDirectory' for system tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a 3-day weather forecast for a city
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes |
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 retrieves a forecast but doesn't mention any behavioral traits such as rate limits, error handling, data sources, or response format. This is a significant gap for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core functionality without any wasted words. It's appropriately sized for a simple tool, 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is incomplete. It lacks details on the forecast format (e.g., temperature units, time intervals), error cases, or how it differs from sibling tools, leaving gaps for the agent to navigate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the schema provides no semantic context. The description adds value by specifying that the parameter is a 'city', but it doesn't clarify format (e.g., city name, coordinates) or constraints. This partial compensation aligns with the baseline for minimal param info.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get') and resource ('3-day weather forecast for a city'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from the sibling 'currentWeather' tool, which likely provides current conditions rather than a forecast, so it misses the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 'currentWeather' or 'searchCity'. It lacks any mention of prerequisites, exclusions, or contextual cues, leaving the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate Images
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | Model to use: flux.1-kontext-pro or gpt-image-1 | gpt-image-1 |
| n | No | Number of images to generate | |
| prompt | Yes | Text description of the desired image | |
| quality | No | Image quality | |
| size | No | Image size | 1024x1024 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure but offers none. It doesn't mention whether this is a read or write operation, what permissions might be required, rate limits, cost implications, or what happens when images are generated. For an image generation tool with potentially significant computational resources, this lack of transparency is critical.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While technically concise with only two words, this represents under-specification rather than effective brevity. The description fails to convey essential information that would help an agent use the tool correctly. Every word should earn its place, but here the words don't provide meaningful value beyond the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of an image generation tool with 5 parameters, no annotations, and no output schema, the description is completely inadequate. It doesn't explain what the tool returns, what formats images might be in, error conditions, or any behavioral characteristics. The agent would struggle to use this tool effectively based solely on this description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents all 5 parameters. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline score is 3 even with no parameter details in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Tautological: description restates name/title.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides absolutely no guidance on when to use this tool versus alternatives. There is no mention of appropriate contexts, prerequisites, or comparisons to sibling tools like 'editImages' for image manipulation. The agent receives zero direction on application scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get details about the currently active Azure subscription
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool retrieves details but doesn't disclose behavioral traits such as whether it requires authentication, how it determines the 'current' subscription, potential rate limits, or error handling. This leaves significant gaps for a tool interacting with cloud resources.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose with zero waste. Every word earns its place, making it easy to parse quickly without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of Azure subscriptions and lack of annotations or output schema, the description is incomplete. It doesn't explain what details are returned (e.g., JSON structure, fields like subscriptionId), authentication requirements, or how 'current' is determined, which are critical for effective use in a cloud context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, and the baseline for 0 parameters is 4, as it avoids unnecessary information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get details about') and resource ('currently active Azure subscription'), making the purpose immediately understandable. It distinguishes from sibling tools like 'listAzureSubscriptions' by focusing on the current subscription rather than listing all. However, it doesn't specify what details are included (e.g., ID, name, quota), keeping it from 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing information about the active Azure subscription, but provides no explicit guidance on when to use this versus alternatives like 'listAzureSubscriptions' or prerequisites (e.g., authentication state). The context is clear but lacks explicit when/when-not instructions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get basic system information like OS, Node version, etc.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 tool retrieves information, implying a read-only operation, but doesn't specify whether it requires permissions, has rate limits, returns structured data, or handles errors. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Get basic system information') and adds clarifying examples ('like OS, Node version, etc.'). There is no wasted language, and it's appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It explains what the tool does but lacks details on behavioral aspects like return format or error handling. For a basic info-retrieval tool, this is acceptable but leaves room for improvement in transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't mention parameters, which is appropriate. A baseline score of 4 is given as it correctly avoids unnecessary parameter details for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('basic system information'), and provides concrete examples ('OS, Node version, etc.'). However, it doesn't explicitly differentiate this tool from potential siblings that might also retrieve system information, though none are listed among the provided sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for usage, or exclusions. While the sibling tools list doesn't include obvious alternatives for system info, the description itself provides no usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List resource groups in a selected Azure subscription using MCP elicitation
| Name | Required | Description | Default |
|---|---|---|---|
| subscriptionId | No | Azure subscription ID (will be elicited if not provided) |
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 mentions 'using MCP elicitation' which adds some context about parameter handling, but doesn't describe what the tool returns (list format, pagination, error conditions), authentication requirements, rate limits, or whether this is a read-only operation. For a cloud resource listing tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point. It's appropriately sized for a simple listing tool and front-loads the core purpose. However, the phrase 'using MCP elicitation' could be slightly clearer for users unfamiliar with MCP terminology.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a cloud resource listing tool with no annotations and no output schema, the description is incomplete. It doesn't explain what information is returned about resource groups, how results are formatted, whether there are limitations or prerequisites, or how this integrates with the Azure authentication context. The description should provide more operational context given the complexity of Azure resource management.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents the subscriptionId parameter. The description adds marginal value by mentioning 'MCP elicitation' which explains how the parameter can be obtained if not provided, but doesn't add meaningful semantic context beyond what's in the schema. With 1 parameter and complete schema coverage, baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List' and resource 'resource groups in a selected Azure subscription', making the purpose unambiguous. It distinguishes from siblings like 'listAzureSubscriptions' by focusing on resource groups rather than subscriptions. However, it doesn't fully differentiate from potential sibling tools that might also list Azure resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'using MCP elicitation' which hints at how the subscriptionId parameter can be obtained, but provides no guidance on when to use this tool versus alternatives like 'listAzureSubscriptions' or 'getCurrentAzureSubscription'. There's no explicit when/when-not usage context or comparison to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all Azure subscriptions available to the current user
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 ('List all Azure subscriptions') but lacks details on permissions required, rate limits, pagination, or response format. For a tool that likely interacts with cloud resources, 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse. Every part of the sentence contributes directly to understanding the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 likely returns a list of subscriptions, the description is incomplete. It doesn't explain what data is returned (e.g., subscription IDs, names, states) or any behavioral aspects like error handling. For a cloud resource tool, this leaves too much unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param details, which is appropriate. Baseline is 4 for 0 params, as it avoids unnecessary information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('Azure subscriptions'), specifying that it retrieves subscriptions 'available to the current user'. It distinguishes from siblings like 'getCurrentAzureSubscription' (singular vs. plural) and 'listAzureResourceGroups' (subscriptions vs. resource groups). However, it doesn't explicitly contrast with all siblings, so it's not a perfect 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 when to choose 'listAzureSubscriptions' over 'getCurrentAzureSubscription' or other tools like 'listDirectory', nor does it specify prerequisites or exclusions. This leaves the agent with minimal context for decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List files and directories in the current or specified path
| Name | Required | Description | Default |
|---|---|---|---|
| path | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the action but lacks behavioral details: it doesn't specify output format (e.g., list structure, error handling), permissions required, rate limits, or whether it's read-only (implied but not explicit). For a 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('List files and directories') and specifies the scope. There is zero waste, and every word earns its place by clarifying the tool's purpose without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (file system interaction), lack of annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't address key contextual aspects like return values, error cases, or system dependencies, leaving gaps for an AI agent to infer behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions 'current or specified path', which hints at the 'path' parameter but doesn't explain its semantics (e.g., format, defaults, validation). With 1 parameter undocumented in both schema and description, the description adds minimal value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('files and directories'), specifying the scope ('in the current or specified path'). It distinguishes from siblings like 'searchCity' or 'executeCommand' by focusing on file system navigation. However, it doesn't explicitly differentiate from tools like 'getSystemInfo' that might also involve system exploration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 (e.g., file system access), exclusions (e.g., not for remote paths if unsupported), or comparisons to siblings like 'searchCity' for location-based queries. Usage is implied by the action but not contextualized.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find cities matching a query string
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It states the action ('find cities') but doesn't describe what the tool returns (e.g., list of cities with details), whether it has rate limits, authentication needs, or error conditions. This leaves significant gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point with no wasted words. It's appropriately front-loaded with the core action, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with no annotations, no output schema, and 0% schema description coverage, the description is insufficient. It doesn't explain what the tool returns (e.g., city names, coordinates, populations), how results are structured, or any behavioral aspects like pagination or error handling, leaving the agent with significant uncertainty.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter documentation. The description mentions 'query string' which aligns with the 'query' parameter, but doesn't explain what constitutes a valid query (e.g., partial names, case sensitivity) or provide examples. With 1 parameter and low coverage, this adds minimal value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('find') and resource ('cities') with the action ('matching a query string'), making the purpose immediately understandable. However, it doesn't differentiate from potential sibling tools like 'currentWeather' or 'forecast' that might also involve city data, so it doesn't achieve full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 'currentWeather' and 'forecast' that likely involve cities, there's no indication whether this is for general city lookup versus weather-specific queries, nor any prerequisites or exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0currentWeathereditImagesexecuteCommandforecastgenerateImagesgetCurrentAzureSubscriptiongetSystemInfolistAzureResourceGroupslistAzureSubscriptionslistDirectorysearchCityScored across 11 tools
The tools cover distinct domains like weather, Azure, system operations, and image editing, but within domains there is some overlap. For example, currentWeather and forecast both handle weather data but are clearly differentiated by time scope, while editImages and generateImages both involve images but have different purposes. The descriptions help clarify boundaries, but an agent might still need to carefully parse them to avoid misselection between related tools.
Naming conventions are inconsistent across the tool set. Some tools use camelCase (e.g., currentWeather, getCurrentAzureSubscription), others use snake_case (e.g., list_azure_resource_groups is implied but not fully consistent in the list), and verbs vary (e.g., 'get', 'list', 'execute', 'edit', 'generate', 'search'). This mixed pattern reduces predictability and readability, making it harder for agents to infer tool purposes from names alone.
With 11 tools, the count is reasonable for a multi-feature server covering weather, Azure, system info, and image operations. It's slightly high but manageable, as each tool appears to serve a specific function without obvious redundancy. The scope is broad, so 11 tools is appropriate to cover the diverse domains without feeling overly heavy or thin.
The tool set shows notable gaps in coverage for the implied domains. For weather, it includes current and forecast but lacks historical data or alerts. For Azure, it has subscription and resource group listing but misses key operations like creating/deleting resources or managing VMs. For images, edit and generate are present but without details on formats or transformations. This partial coverage may lead to agent workarounds or failures in complex workflows.
OCR, transcription, file extraction, and image generation for AI agents via MCP.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
Automate 1,000+ services from any MCP-compatible AI agent: build Applets, run actions and queries.
Multi-model AI image and video generator. 14 models behind one OAuth-secured MCP endpoint.
