@mhdd_24/api-scenario-mcp
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., "@@mhdd_24/api-scenario-mcpGenerate a multi-step API workflow for user signup and email verification."
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.
@mhdd_24/api-scenario-mcp
Generate complete multi-step API workflows.
Same architecture as @mhdd_24/sublime-mcp.
Full documentation: docs/WIKI.md
How it works (30 seconds)
You (chat) → MCP client → api-scenario-mcp → API Scenario APIs / CLIs / local toolsRelated MCP server: ControlAPI-MCP
Prerequisites
Requirement | Notes |
Node.js 18+ | ESM TypeScript MCP server |
Credentials / CLIs | See environment variables below |
Install
Option A — npm (after publish)
npm install -g @mhdd_24/api-scenario-mcpOption B — npx
npx @mhdd_24/api-scenario-mcpOption C — clone and build
git clone https://github.com/Mhdd-24/API-Scenario-MCP.git
cd API-Scenario-MCP
npm install
npm run build
node dist/index.jsConfigure Cursor
Edit ~/.cursor/mcp.json:
{
"mcpServers": {
"apiscen": {
"command": "npx",
"args": ["-y", "@mhdd_24/api-scenario-mcp"],
"env": {
"PROJECT_ROOT": "..."
}
}
}
}Local development:
{
"command": "node",
"args": ["/absolute/path/to/API-Scenario-MCP/dist/index.js"]
}Environment variables
Variable | Description |
| Default project/repository root |
Tools
Tool | Description |
| Health check for API Scenario MCP. |
| Generate a multi-step API workflow. |
| Convert a scenario outline to HTTP steps. |
License
ISC
Available Tools
3 toolsapiscen_generateC
Generate a multi-step API workflow.
| Name | Required | Description | Default |
|---|---|---|---|
| goal | Yes | Business goal | |
| endpoints | No | Known endpoints |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description is the sole source of behavioral information. It does not reveal whether generation is synchronous, whether it creates a persisted artifact, what the return value looks like, or if there are side effects. The phrase 'multi-step API workflow' hints at the output shape but nothing more.
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, front-loaded sentence with no wasted words. It efficiently states the tool's core action, though it sacrifices behavioral detail for brevity.
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 tool with no output schema and no annotations, the description should compensate by explaining what the generated workflow looks like' or how the result is returned. It also does not connect to the sibling tools. The current description leaves too many gaps for an agent to confidently consume the output or integrate the tool into a larger process.
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 two parameters (goal and endpoints) are already documented in the input schema. The description adds no extra meaning about how these parameters influence the generated workflow, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Generate') and a concrete resource ('multi-step API workflow'), which clearly distinguishes the tool from its siblings (apiscen_status, apiscen_to_http). It is not a tautology and gives a basic idea of the function.
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?
There is no guidance on when to use this tool versus apiscen_status or apiscen_to_http. The description simply states what it does; it never mentions alternatives, prerequisites, or selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
apiscen_statusA
Health check for API Scenario MCP.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description is the sole source of behavioral disclosure. 'Health check' communicates a read-only, non-mutating operation but does not disclose output shape, failure semantics, or whether any state is touched. For a zero-parameter status endpoint, this is minimally adequate but not rich.
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?
A single, front-loaded sentence with no redundant words. It is appropriately sized for the trivial surface area of a zero-parameter health check.
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?
The operation is simple and parameterless, so the description is largely complete. The only gap is the absence of an explicit statement about the return value, but 'health check' strongly implies a status response. Since no output schema exists, the description could have said more, but the gap is minor.
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 no parameters, and the schema already documents an empty object with 100% coverage. The description adds nothing needed for parameters, and the baseline for zero-parameter tools is 4.
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 uses a specific verb phrase ('Health check') with a clear resource ('API Scenario MCP'). It is readily distinguishable from sibling tools apiscen_generate and apiscen_to_http, which imply different operations. However, it doesn't elaborate on what 'health' means in this context.
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 explicit when-to-use guidance or mention of alternatives is provided. Usage is implied by the term 'health check,' which is sufficient for a simple status tool, but there is no direct statement of when to prefer this over siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
apiscen_to_httpC
Convert a scenario outline to HTTP steps.
| Name | Required | Description | Default |
|---|---|---|---|
| scenario | Yes | Scenario text |
TDQS
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 only says 'convert,' which implies a transformation, but does not specify whether it is a pure function, what side effects (if any) occur, what the output format is, or any error behavior. This is a significant gap for a conversion tool.
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 with no filler or redundant phrasing. It is appropriately short for a simple tool, and the core action is front-loaded. It could be slightly more informative without violating conciseness, but as-is it is well-structured.
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?
Despite having only one parameter, the description lacks essential context such as what constitutes a 'scenario outline,' what 'HTTP steps' entail, and what the output looks like. With no output schema and no annotations, this minimal description leaves the agent guessing about format, expected input syntax, and result structure.
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 schema already describes the only parameter ('scenario' as 'Scenario text') with 100% coverage, so the description adds no additional meaning beyond what the schema provides. Baseline 3 is appropriate when the schema fully documents parameters.
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 a clear verb ('Convert') and a specific resource ('scenario outline to HTTP steps'), which tells the agent what the tool does. However, it does not explicitly distinguish itself from siblings like apiscen_generate, so it's not fully differentiated.
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 gives no guidance on when to use this tool versus the alternatives (apiscen_status, apiscen_generate). There's no mention of context, prerequisites, or exclusions, so an agent must infer usage from the name alone.
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.
3 tool updates
v1.0.0- First observed
apiscen_generate - First observed
apiscen_status - First observed
apiscen_to_http
TDQS
Scored across 3 tools
Each tool has a clearly distinct purpose: status is a health check, generate creates a workflow, and to_http converts an outline to HTTP steps. There is no meaningful overlap or ambiguity among the three tools.
All tools share the consistent apiscen_ prefix and use snake_case, but the naming pattern is slightly uneven: status is a noun, generate is a verb, and to_http is a converter-style phrase. The naming is still predictable and readable overall.
Three tools is an appropriate size for this focused API scenario utility. Each tool supports a distinct part of the workflow without being redundant or bloated.
The core pipeline of generating a scenario and converting it to HTTP steps is covered, with a health check for operational use. Minor gaps exist, such as no explicit validation or management tools for scenarios, but they do not undermine the stated purpose.
Maintenance
Related MCP Connectors
MCP server for AI access to SmartBear tools, including BugSnag, Reflect, Swagger, PactFlow, QTM4J.
327 dev tools via REST API and MCP. Generate Dockerfiles, schemas, K8s, APIs, and more.
MCP server for AI access to Swagger by SmartBear.
Related MCP Servers
- AlicenseBqualityBmaintenanceA configurable MCP server that adapts any HTTP API into an MCP toolset with generic HTTP tools (GET, POST, PUT, DELETE) and pluggable authentication. Includes API discovery scripts and supports dynamic tool generation from OpenAPI specs or wordlist scans.51MIT
- AlicenseAqualityCmaintenanceConverts any OpenAPI/REST API into MCP tools with dynamic server switching, variable substitution, and runtime configuration. Enables seamless interaction with multiple API environments through natural language without pre-configuration.125MIT
- FlicenseNot gradedqualityDmaintenanceEnables conversational API testing via MCP, allowing users to make HTTP requests, decode JWT tokens, and validate JSON schemas through natural language.-
- AlicenseNot gradedqualityDmaintenanceProvides a standardized MCP interface for interacting with HTTP tools and services, enabling unified API access and management.MIT