The latest features and updates from Roadie.
Introducing the Roadie MCP Server
Roadie has always served a wide range of users, but first and foremost we’re a software catalog and automation portal for software engineers.
As such, Roadie (and Backstage, upon who’s shoulders we stand) has always been a good dashboard, acting as a single pane of glass for all kinds of fragmented dev tools and scattered pieces of documentation.
But it’s always been a tool that you had to step out of your development workflow in order to access.
The classic flow for most engineers using Roadie was to either have Roadie open as a broswer window as they worked, or to step out of the IDE to ask questions of the Catalog, get wider context on your work, or provision some new service using the Scaffolder.
That context switch has always been a problem we’d like to solve.
Luckily the answer is here: it’s the Roadie Model Context Protocol (MCP) Server(s).
What’s an MCP Server?
MCP is a protocol introduced by Anthropic in November 2024.
The protocol itself is based on a simple client-server architecture. MCP Clients - like the new wave of IDEs (Cursor, Windsurf, VSCode with Copilot, etc) - act as clients that can call MCP servers to get additional information.
MCP servers allow the LLMs at the heart of newer software development applications to receive additional, specific context about the query that a user is making which wouldn’t be well represented in the foundational model. MCP servers are therefore great for enriching responses when a base LLM simply wouldn’t be able to generate a good enough answer.
For example, if you ask ChatGPT or Claude to generate you a Backstage Scaffolder Template it will do a good-ish job because it was trained on enough open-source templates to do that. The format will be largely correct, for example. But, it will also hallucinate actions because it thinks they might logically exist. It also won’t know which scaffolder actions you have installed. This isn’t great if you want to actually run that template or automate a development flow involving the scaffolder.
If you tried the same case again but this time with an MCP which returned useable scaffolder actions upon request, then the LLM has a much better chance of generating a functional Template.
How can I use it?
The Roadie MCP server works with any tools that can act as an MCP client, including Claude Desktop, VSCode Copilot, and Windsurf Editor.
If you have your own MCP client with the capability to interact with remote MCP servers with authentication headers then this should also work.
You’ll need a Roadie API key. Admins have access by default. There’s a role in Roadie which, when enabled, can give users the ability to create their own API key.
Docs on how to get started can be found here: https://roadie.io/docs/details/roadie-mcp/
What can the Roadie MCP servers do?
With the four MCP servers we’ve currently exposed, you can:
- Access catalog entity data, relationships, and documentation
- Discover and retrieve API documentation and specifications
- Find, validate, and execute Backstage scaffolder templates
- Access operational metrics, security data, and compliance information from Tech Insights (if you’re a Tech Insights customer)
Example: OpenAPI specs.
By asking questions in your MCP client, you can integrate two systems, assuming the one you’re integrating with exposes OpenAPI specs documented in Roadie.
You would say something like this to you LLM:
“I need to integrate with our User Management system”
The MCP client will then make a call to our MCP server. The steps will look something like this:
- Searches for user-related APIs using find-api-specs
- Retrieves specifications for relevant APIs
- Explains available endpoints, authentication, and schemas
- Provides integration guidance and code examples
You’ll then get an implementation of an integration between your current code base and the User Management system, that takes into account how the User Management API actually works.
Example: Creating a new project using the scaffolder
You would say something like this to you LLM:
“Create a new React frontend application”
The MCP client will then make a call to our MCP server. The steps will look something like this:
- Searches for React templates using find-scaffolder-templates
- Shows available templates and their requirements
- Guides user through providing necessary parameters
- Validates inputs using validate-template-values
- Executes template using run-scaffolder-template
- Monitors progress and reports results
You’ll then get an complete application based on the provided template.
How does authentication & permissions work?
Getting permissions right in the context of MCP Servers, and AI and agentic systems more broadly, can be tricky.
To solve that for the Roadie MCP Server(s), we’ve architected the Roadie MCP to have access to the authentication and permissions that the same user would have in the web app. We do that by combining two things:
- Roadie RBAC plugin
- Roadie API using user-scoped tokens
A user generates an API token in the web app for use in their MCP Client of choice. That token inherits the permission that the user has. It’s evaluated on each call to ensure the permissions stay in sync. Tokens expire after 1 year.
When will it be generally available?
Folks who have opted in to our early-access AI features will have access shortly. After that we’ll begin a wider rollout. Existing customers will be sent a message in the communication tool of choice (Slack or Teams) to onboard them.
General Availability is expected in August 2025.