The AsyncAPI-MCP server gives AI assistants direct access to the AsyncAPI specification, enabling search, exploration, and retrieval of spec content across versions.
List available versions — Retrieve all stable AsyncAPI spec versions available as GitHub tags
Get spec metadata — Fetch source, version, cache, and size metadata for any spec version (defaults to latest)
Search the spec — Search the AsyncAPI specification by keyword, returning matching snippets (up to 20 results)
Get a specific section — Retrieve a section by heading text or slug (e.g., "Info Object" or "info-object")
Validate spec files — Validate raw AsyncAPI YAML or JSON content and return any errors
Access structured resources — Retrieve the full spec via resource URIs (asyncapi://spec/latest or asyncapi://spec/{version})
Most tools accept an optional version parameter (e.g., "3.0.0") to target a specific release, defaulting to the latest.
An MCP (Model Context Protocol) server that gives AI assistants access to the AsyncAPI specification. Search, explore, and retrieve any version of the spec directly from your coding tool.
Search the AsyncAPI specification by keyword
Retrieve specific sections by heading or slug
List all stable spec versions available as GitHub tags
Get metadata about the spec (version, source, cache info, size)
Version-aware — query any released spec version, or default to the latest
Caching — ETag/Last-Modified-based HTTP caching with a 10-minute TTL on tag lookups
Related MCP server: EasyPeasyMCP
The server runs a free public instance at https://asyncapi-mcp.onrender.com — no account, no API key. Just point your client at it.
Claude Code:
claude plugin marketplace add Souvikns/asyncapi-mcpThen, inside a Claude Code session:
/plugin install asyncapi-mcp@asyncapi-mcpAny other MCP client — add this to your MCP client configuration:
{
"mcpServers": {
"asyncapi": {
"url": "https://asyncapi-mcp.onrender.com/mcp"
}
}
}See the Configuration section below for client-specific instructions, and the Deployment section if you'd rather run your own instance.
Node.js v20 or later
npm installnpm run buildStreamable HTTP (for local development):
npm run devThe server starts on http://localhost:3000/mcp by default, and the website is served at http://localhost:3000/. Set the PORT environment variable to use a different port:
PORT=8080 npm run devStdio (for local MCP clients):
npm run start:stdioTool | Description | Parameters |
| List stable AsyncAPI spec versions available as GitHub tags | None |
| Return source, version, cache, and size metadata for a spec |
|
| Search the spec and return matching snippets |
|
| Validate raw AsyncAPI YAML or JSON content and return validation errors |
|
| Return a section by heading text or slug |
|
Resource | URI | Description |
Latest AsyncAPI Spec |
| The latest AsyncAPI markdown specification from the master branch |
AsyncAPI Spec by Version |
| A specific version of the spec fetched from the matching GitHub release tag |
The /mcp endpoint has no authentication — it's rate-limited per IP address instead (60 requests per minute by default). Exceeding the limit returns a 429 response with a Retry-After header. The /health endpoint is never rate-limited, so platform health checks always succeed. Limits are configurable via the RATE_LIMIT_MAX and RATE_LIMIT_WINDOW_MS environment variables if you're running your own instance. Behind a reverse proxy (like Render's), set TRUST_PROXY_HOPS to the number of proxy hops in front of the app (verify by logging the effective config — see the startup log) so IP-based limiting isn't trivially bypassable, and set ALLOWED_HOSTS to your public hostname(s) (comma-separated) to restore DNS-rebinding protection.
Use these configs to connect to the hosted instance at https://asyncapi-mcp.onrender.com — no setup or API key required. Running your own instance instead? Swap in your own URL (see Deployment).
From your terminal, add the marketplace:
claude plugin marketplace add Souvikns/asyncapi-mcpThen, inside a Claude Code session, install the plugin:
/plugin install asyncapi-mcp@asyncapi-mcp{
"mcpServers": {
"asyncapi": {
"url": "https://asyncapi-mcp.onrender.com/mcp"
}
}
}Add to .cursor/mcp.json in your project root:
{
"mcpServers": {
"asyncapi": {
"url": "https://asyncapi-mcp.onrender.com/mcp"
}
}
}Add to .vscode/mcp.json in your project root:
{
"servers": {
"asyncapi": {
"url": "https://asyncapi-mcp.onrender.com/mcp",
"type": "http"
}
}
}Add to your Windsurf MCP settings:
{
"mcpServers": {
"asyncapi": {
"serverUrl": "https://asyncapi-mcp.onrender.com/mcp"
}
}
}In Cline's MCP settings, add:
{
"mcpServers": {
"asyncapi": {
"url": "https://asyncapi-mcp.onrender.com/mcp"
}
}
}Add to your OpenCode configuration:
{
"mcp": {
"servers": {
"asyncapi": {
"url": "https://asyncapi-mcp.onrender.com/mcp"
}
}
}
}Add to your Zed settings.json:
{
"context_servers": {
"asyncapi": {
"url": "https://asyncapi-mcp.onrender.com/mcp"
}
}
}Use these configs when running the server locally with npm run dev. Make sure the server is running before connecting — no signup or API key needed.
{
"mcpServers": {
"asyncapi": {
"url": "http://localhost:3000/mcp"
}
}
}{
"servers": {
"asyncapi": {
"url": "http://localhost:3000/mcp",
"type": "http"
}
}
}Replace the Render URL in the configs above with http://localhost:3000/mcp.
Render provides a free web service tier with no credit card required. This is the easiest way to host your MCP server.
750 free instance hours per month — plenty for a single MCP server
Sleeps after 15 minutes of idle time — the service spins down when nobody is using it
Wakes up on next request — takes about 30–60 seconds to respond after sleep
No credit card required — truly $0
Your code pushed to a public GitHub repository
In the Render dashboard, click New → Web Service.
Connect your GitHub account and select your repository.
Render will auto-detect the Node.js buildpack.
Set the following:
Name: asyncapi-mcp (or whatever you prefer)
Runtime: Node
Build Command: npm install && npm run build
Start Command: npm start
Instance Type: Free
Add environment variables:
PORT = 3000
NODE_ENV = production
TRUST_PROXY_HOPS = 1 (verify this against Render's actual proxy chain post-deploy — see Rate Limiting)
ALLOWED_HOSTS = asyncapi-mcp.onrender.com (restores DNS-rebinding protection; use your own domain if self-hosting under a different one)
Click Create Web Service.
Render will build and deploy your app. Once finished, you'll get a public URL like https://asyncapi-mcp.onrender.com — visiting it shows the website, and the server is immediately usable with no signup step.
This repo already includes .claude-plugin/plugin.json and .claude-plugin/marketplace.json. If you deploy your own instance, update the url in .claude-plugin/plugin.json to point at your Render URL. Anyone can then install it in two steps: first, from a terminal, add your fork as a marketplace —
claude plugin marketplace add <your-github-username>/<your-repo>— and then, inside a Claude Code session (not a shell — this is a Claude Code slash command), install the plugin from it:
/plugin install asyncapi-mcp@asyncapi-mcpYour Render domain is already configured in the Configuration section above.
You can verify the server is running by visiting:
https://asyncapi-mcp.onrender.com/healthBuild and run with the included Dockerfile:
docker build -t asyncapi-mcp .
docker run -p 3000:3000 asyncapi-mcpThe HTTP server will be available at http://localhost:3000/mcp and the website at http://localhost:3000/.
npm install
npm run build
npm startThe server starts on http://localhost:3000/mcp by default.
Once configured, you can ask your AI assistant questions like:
"What does the AsyncAPI spec say about server objects?"
"Search the AsyncAPI spec for 'channels'"
"Get the Info Object section from version 2.6.0"
"List all available AsyncAPI spec versions"
"What are the differences between messages in AsyncAPI 2.x and 3.x?"
"Show me the spec section about schema definitions"
Requires Node.js v20+:
npm install
npm run build
npm run devThis builds the website on first run and starts the server. Then visit http://localhost:3000, or use http://localhost:3000/mcp directly in your MCP client config — no signup or API key needed.
# In another terminal: run the website dev server with hot reload
npm run dev:web
# Build TypeScript to dist/ and the website to web/dist/
npm run build
# Run the stdio server (for local MCP clients)
npm run start:stdio
# Type-check without emitting
npx tsc --noEmitReturn source, version, cache, and size metadata for the latest AsyncAPI specification.
| Name | Required | Description | Default |
|---|---|---|---|
| version | No | Optional spec version, for example "3.0.0". Defaults to latest from master. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Describes what is returned but does not disclose side effects, authentication needs, or error behavior (e.g., if version not found). Adequate but minimal.
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?
Single sentence of 12 words, front-loaded with key information. No fluff or 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?
For a simple tool with one optional parameter and no output schema, the description is largely complete. Could specify the output format, but the complexity is low and the listed metadata fields are sufficient.
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?
Single parameter 'version' is fully described in schema with example and default behavior (100% coverage). Tool description adds no extra meaning, so baseline score 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?
Description clearly states it returns metadata (source, version, cache, size) for the latest AsyncAPI spec, distinguishing it from siblings like get_asyncapi_spec_section (returns a section) and list_asyncapi_spec_versions (lists versions).
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?
Implied usage: when metadata about the spec is needed. The optional version parameter is noted, but no explicit contrast with alternatives like search or validate is provided. Clear enough given sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return one section from the latest AsyncAPI markdown specification by heading text or slug.
| Name | Required | Description | Default |
|---|---|---|---|
| version | No | Optional spec version, for example "3.0.0". Defaults to latest from master. | |
| heading | Yes | Heading text or slug, for example "Info Object" or "info-object". |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It does not specify return format (e.g., markdown text), error handling for missing headings, or whether it is read-only. The behavioral details are 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?
One sentence with no fluff. The description front-loads the key action and resource, making it efficient and clear.
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 simplicity (2 params, no output schema), the description covers the core purpose. However, it lacks details on return format and error behavior, which are needed for full completeness without annotations.
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 coverage is 100%, so baseline is 3. The description adds minimal extra context (e.g., 'latest from master') but mainly restates schema info. No significant value added 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 'Return', the resource 'one section from the latest AsyncAPI markdown specification', and the mechanism 'by heading text or slug'. It distinctively differentiates from sibling tools like get_asyncapi_spec_metadata or search_asyncapi_spec.
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 guidance on when to use versus alternatives. The description implies use when a specific section is needed by heading, but lacks exclusion criteria or comparisons with other tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List stable AsyncAPI specification versions available as GitHub tags.
| 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 must fully disclose behavioral traits. It only states it lists stable versions from GitHub tags, lacking details on data freshness, rate limits, pagination, or whether it's read-only. Minimal behavioral disclosure.
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, concise sentence with no unnecessary words. It is front-loaded and efficient.
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 simple list tool with no parameters and no output schema, the description is minimally adequate. However, it does not describe the output format (list of strings, objects, etc.) or any potential side effects, leaving gaps in completeness.
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?
There are no parameters, so schema coverage is 100% trivially. The description adds no parameter-level detail, but given zero parameters, the baseline of 4 is justified.
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 the verb 'list' and specifies the resource 'stable AsyncAPI specification versions available as GitHub tags'. It clearly distinguishes from sibling tools which focus on metadata, sections, search, or validation.
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 its use to retrieve version lists but provides no explicit guidance on when to use this tool over alternatives or any exclusions. Given the simple nature, a score of 3 (implied usage) is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the latest AsyncAPI markdown specification and return matching snippets.
| Name | Required | Description | Default |
|---|---|---|---|
| version | No | Optional spec version, for example "3.0.0". Defaults to latest from master. | |
| query | Yes | Search query to find in the AsyncAPI specification. | |
| limit | No | Maximum number of matching snippets to return. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description partially discloses behavior: it searches the latest spec and returns snippets. However, it does not mention behavior on empty queries, error handling, or the snippet format needed for proper use.
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 concise sentence that front-loads the key action and resource. Every word is necessary and there is no superfluous content.
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 has 3 parameters and no output schema, the description is too sparse. It does not explain return value format, pagination, or behavior when no results are found, leaving gaps for a complete understanding.
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 coverage is 100%, so the description adds little beyond what the schema already provides. The word 'latest' hints at version default, but the schema already describes version semantics adequately.
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 'Search', the resource 'AsyncAPI markdown specification', and the output 'matching snippets'. It distinguishes from sibling tools like get_asyncapi_spec_section or list_asyncapi_spec_versions, which have different purposes.
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 for searching the spec, but does not provide explicit guidance on when to use this tool versus alternatives or special conditions. No when-not or alternative hints are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate raw AsyncAPI YAML or JSON content and return validation errors if the spec is invalid.
| Name | Required | Description | Default |
|---|---|---|---|
| spec | Yes | Raw AsyncAPI document content as YAML or JSON. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It mentions returning errors for invalid specs but does not clarify behavior for valid specs (e.g., empty list vs success message). No mention of permissions, side effects, or performance.
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?
Single sentence, direct and complete. No unnecessary words.
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 simple validation tool with one parameter and no output schema, the description covers the basic purpose and input. However, it lacks explicit mention of the return format (e.g., list of errors) which would improve completeness.
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% (single parameter 'spec' described as 'Raw AsyncAPI document content as YAML or JSON.'). Description adds no extra parameter info beyond the schema, so 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?
Description clearly states verb 'validate', resource 'AsyncAPI YAML or JSON content', and outcome 'return validation errors'. Clearly distinguishes from sibling tools that handle metadata, sections, versions, and search.
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 on when to use this tool versus alternatives like get_asyncapi_spec_metadata or search_asyncapi_spec. The description does not specify prerequisites or contexts where validation is appropriate.
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.
v0.1.1validate_asyncapi_specv0.1.0get_asyncapi_spec_metadataget_asyncapi_spec_sectionlist_asyncapi_spec_versionssearch_asyncapi_specScored across 5 tools
Each tool serves a distinct purpose: metadata retrieval, section access, version listing, search, and validation. No overlap in functionality.
All tools follow a consistent verb_noun pattern with snake_case, such as 'get_asyncapi_spec_metadata' and 'validate_asyncapi_spec', making it predictable.
With 5 tools, the server covers the core operations for an AsyncAPI spec explorer without being too sparse or excessive.
The tool set covers metadata, sections, versions, search, and validation. Minor gap: no direct way to retrieve the entire raw spec, though sections and search can compensate.
MCP server that lets AI assistants use all OneSchema features exposed via the public API.
An MCP server that gives your AI access to the source code and docs of all public github repos
MCP server for AI access to Swagger by SmartBear.
