⚠️ Note: The SmartBear MCP Server is under active development and features may change. Check our GitHub repository for the latest updates and compatibility information.

At SmartBear, we show how our MCP Server enables a secure and intelligent bridge between SmartBear platform data and AI-powered development workflows. By leveraging the Model Context Protocol (MCP), developers can access rich context and capabilities – such as API definitions, governance rules, portal documents, test outcomes, error reports, monitoring insights, and debugging diagnostics – directly within their preferred AI assistants and IDEs.

By surfacing actionable context from across Swagger, Test Hub, QMetry, Zephyr, and BugSnag into tools like GitHub Copilot, Cursor, Claude, and other MCP-compatible clients, MCP Server empowers teams to accelerate design, testing, and troubleshooting workflows, all while keeping developers in their natural flow of work.

Why automation of the API SDLC matters

APIs are the backbone of today’s digital ecosystems – powering integrations, workflows, and user experiences across every industry. Yet despite how essential APIs are, many teams still rely on manual processes for designing, validating, and documenting them.

These manual workflows often introduce familiar challenges:

• API specifications written from scratch
• Server code generated manually and inconsistently
• Governance rules applied unevenly across teams
• Documentation that drifts out of sync with changing APIs
• Multiple tools and hand-offs slowing work down

As expectations for speed, consistency, and scale grow, automation becomes critical. By integrating AI and MCP Tools, teams can eliminate repetitive tasks and ensure API quality while staying focused on building valuable features.

How Swagger MCP Tools works

Swagger MCP Tools together with SmartBear MCP Server centralizes API creation, validation, standardization, versioning, and documentation – all accessible directly from Visual Studio Code or your preferred MCP-enabled environment. AI handles much of the heavy lifting, accelerating the end-to-end API lifecycle.

In our demo, we walk through an example workflow using a sample Train Booking API to illustrate how quickly teams can go from idea to published portal documentation.

Demo

Step-by-Step Demo

Building the “Train Booking API” Using Swagger MCP Tools

The walkthrough below follows the same flow as the demo video, but you don’t need to watch it to understand how everything works. Each step shows how MCP Server brings together design, governance, and documentation into a single, natural workflow.

1. Creating an API with a single prompt

We begin by launching the MCP Server locally. Immediately, twenty-four SmartBear-powered tools become available – everything needed to design, validate, and publish an API.

From there, the process starts with a single instruction:

Create an API for a simple Train Booking in the ‘swaggermcpdemo’ organization

Within seconds, the server generates a complete API definition, including endpoints, request and response schemas, parameters, and descriptions.

2. Checking whether the API already exists

Next, using the Swagger MCP Tools, we confirm whether the API is already present:

Check if Train Booking API exists in organization ‘swaggermcpdemo’

The server confirms the API is indeed available.
From there, we open it directly in Swagger Studio to inspect the definition.

(Swagger Studio provides an interactive UI where developers can view and edit API specs.)

3. Generating a Spring server stub

To move from design to implementation, we ask the MCP Server to generate backend scaffolding:

Get this API and generate a server stub for Spring

Instantly, the system produces a full Spring Boot backend structure. This means developers can jump directly into writing business logic – no setup, no boilerplate, no hand-built scaffolding. Even without seeing it in action, the concept is simple: your API definition becomes runnable backend code in seconds.

4. Creating and applying a custom governance rule

To enforce documentation standards, we create a new governance rule:

Create a new custom rule that checks whether every endpoint has a description

After adding the rule to our organization’s ruleset in Swagger Studio, we intentionally remove one description.
The Spectral engine automatically flags the violation – just as it would in a real project – ensuring consistency across your APIs.

(Spectral is a linting tool that automatically highlights issues in your API spec based on defined rules.)

5. Fixing issues automatically

To resolve the flagged error, we run:

Check standardization

The Swagger MCP Tools analyzes the API, identifies the missing description, and automatically restores or generates the required documentation.
This keeps the API compliant with governance rules – without manual editing.

6. Saving a new API version

With the API updated, we version it:

Fetch the updated API and save it as version 1.0.1 and store it in Swagger

A clear version diff shows exactly what changed (in this case, the restored description). Think of it as Git for APIs – structured, trackable, and transparent.

7. Creating a documentation portal

With design and governance completed, we shift to documentation. We create a new developer portal with two prompts:

Create a new portal called ‘MCP Server Demo’ in the ‘swaggermcpdemo’ organization

Create a product called ‘Train Booking’

When we open the Swagger Portal, a clean documentation space is already in place.

(This is the same type of developer portal customers would use to explore your APIs.)

8. Linking the API and adding user onboarding

Next, we connect the Train Booking API to the new product:

Link the Train Booking API to this documentation

To make the documentation more useful, we add a simple “Getting Started” guide:

Add a getting started guide to this product documentation

Swagger Portal immediately displays the onboarding content – no manual page creation required.

9. Publishing the Portal

To finish, we publish everything with a single command:

Publish the Train Portal

The result is a polished, fully populated developer portal – complete with API documentation, onboarding guides, product details, and a live API reference.

Even if you haven’t watched the demo video, the takeaway is clear:
The entire workflow – API creation, validation, code generation, governance, versioning, and documentation – can be performed through natural-language prompts.

Why Swagger Studio and Portal MCP Tools Stand Out

Swagger Studio and Portal MCP Tools streamlines the API lifecycle by combining design, governance, documentation, and development into a single workflow. It removes repetitive manual steps and gives teams the ability to move from an idea to a working API with minimal friction.

Prompt-Driven API Creation

Developers can describe the API they need in plain language, and a complete definition is generated – including endpoints, schemas, and descriptions – ready for review or implementation.

Automated Validation and Governance

As teams refine their APIs, the APIs can be continuously checked for compliance with organizational standards. Rules are enforced automatically, helping maintain consistency across large and distributed teams.

Built-In Versioning and Comparison

Auto versioning of the APIs. Clear diffs show exactly what changed, making reviews, audits, and collaboration significantly easier.

Real-Time Documentation and Portal Publishing

Documentation stays synchronized with the API as it evolves. Teams can generate or update a developer portal with a single instruction, ensuring that consumers always have accurate and up-to-date information.

Deep Integration with SmartBear’s Platform

MCP Server connects seamlessly with Swagger, Spectral, Portal, and other SmartBear products, enabling a cohesive workflow without switching tools.

Benefits for Development Teams

Adopting our SmartBear MCP Server delivers tangible improvements across the organization:

• Less manual work
  Repetitive tasks like scaffolding, documentation updates, and rule checks become automated.
• Greater consistency across teams
  Standards are enforced automatically, ensuring all APIs within an organization follow the same structure and quality expectations.
• Documentation that stays in sync
  When the API evolves, the docs evolve with it – reducing the common drift between implementation and documentation.
• Faster debugging and troubleshooting
  By connecting to BugSnag and other SmartBear tools, errors and context surface directly into the developer workflow.
• Developers stay in their natural flow
  Instead of jumping across interfaces, the MCP Server brings the right context directly into IDEs and AI assistants, cutting down on disruptions.
• Faster delivery
  Teams ship APIs sooner while maintaining reliability, governance, and documentation quality.

Accelerate your API Development with MCP Server

MCP Server gives teams a unified, streamlined way to design, evolve, and publish APIs with far less overhead. Whether you’re building a new service or improving an existing one, the workflow stays fast, consistent, and easy to manage.

For more information, detailed guides, and the latest updates, visit the SmartBear MCP Server documentation or check our GitHub repository. Start exploring MCP Server today and see how it can simplify your API lifecycle from design to production.