一个 MCP（模型上下文协议）服务器，让 AI 助手能够访问 AsyncAPI 规范。直接从你的编码工具中搜索、探索并获取任何版本的规范。
在 Glama 浏览器中试用 — 无需安装。
搜索：按关键字搜索 AsyncAPI 规范
获取：通过标题或 slug 获取特定章节
列出：列出所有作为 GitHub 标签提供的稳定规范版本
获取元数据：获取关于规范的元数据（版本、来源、缓存信息、大小）
版本感知：查询任何已发布的规范版本，或默认为最新版本
缓存：基于 ETag/Last-Modified 的 HTTP 缓存，标签查找具有 10 分钟的 TTL
Related MCP server: EasyPeasyMCP
使用 Glama 上托管的服务器 — 无需本地设置。将以下内容添加到你的 MCP 客户端配置中：
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}请参阅下方的 配置 部分，了解特定客户端的说明。
Node.js v20 或更高版本
npm installnpm run build流式 HTTP（用于本地开发）：
npm run dev服务器默认在 http://localhost:3000/mcp 启动。设置 PORT 环境变量以使用不同的端口：
PORT=8080 npm run devStdio（用于部署）：
npm start工具 | 描述 | 参数 |
| 列出作为 GitHub 标签提供的稳定 AsyncAPI 规范版本 | 无 |
| 返回规范的来源、版本、缓存和大小元数据 |
|
| 搜索规范并返回匹配的代码片段 |
|
| 验证原始 AsyncAPI YAML 或 JSON 内容并返回验证错误 |
|
| 通过标题文本或 slug 返回章节 |
|
资源 | URI | 描述 |
最新 AsyncAPI 规范 |
| 来自 master 分支的最新 AsyncAPI Markdown 规范 |
按版本划分的 AsyncAPI 规范 |
| 从匹配的 GitHub 发布标签获取的特定版本规范 |
使用这些配置连接到 Glama 托管的服务器。无需本地设置。
添加到 ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) 或 %APPDATA%\Claude\claude_desktop_config.json (Windows)：
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}添加到项目根目录的 .cursor/mcp.json：
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}添加到项目根目录的 .vscode/mcp.json：
{
"servers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp",
"type": "http"
}
}
}添加到你的 Windsurf MCP 设置中：
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}在 Cline 的 MCP 设置中，添加：
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}添加到你的 OpenCode 配置中：
{
"mcp": {
"servers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}
}添加到你的 Zed settings.json：
{
"context_servers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}在使用 npm run dev 本地运行服务器时使用这些配置。在连接前请确保服务器正在运行。
{
"mcpServers": {
"asyncapi": {
"url": "http://localhost:3000/mcp"
}
}
}{
"mcpServers": {
"asyncapi": {
"url": "http://localhost:3000/mcp"
}
}
}{
"servers": {
"asyncapi": {
"url": "http://localhost:3000/mcp",
"type": "http"
}
}
}将上述配置中的 Glama URL 替换为 http://localhost:3000/mcp。
此服务器部署在 Glama.ai 上。请参阅 glama.ai/mcp/servers/Souvikns/asyncapi-mcp 获取托管实例。
要部署你自己的实例，请使用 stdio 传输进行构建和运行：
npm run build
npm start包含一个 Dockerfile 用于容器化部署：
docker build -t asyncapi-mcp .
docker run -p 3000:3000 asyncapi-mcp配置完成后，你可以向 AI 助手询问如下问题：
“AsyncAPI 规范中关于服务器对象（server objects）是怎么说的？”
“在 AsyncAPI 规范中搜索 'channels'”
“获取 2.6.0 版本中的 Info Object 章节”
“列出所有可用的 AsyncAPI 规范版本”
“AsyncAPI 2.x 和 3.x 中的消息有什么区别？”
“向我展示关于模式定义（schema definitions）的规范章节”
# Install dependencies
npm install
# Build TypeScript to dist/
npm run build
# Run the HTTP server (local development)
npm run dev
# Run the stdio server (for deployment)
npm start
# 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.
MCP server for OpenAI API (chat completions, image generation, embeddings) via AceDataCloud
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.
