Ein MCP-Server (Model Context Protocol), der KI-Assistenten Zugriff auf die AsyncAPI-Spezifikation gewährt. Suchen, erkunden und rufen Sie jede Version der Spezifikation direkt aus Ihrem Coding-Tool ab.
Probieren Sie es in Ihrem Browser auf Glama aus — keine Installation erforderlich.
Suche in der AsyncAPI-Spezifikation nach Schlüsselwörtern
Abruf spezifischer Abschnitte nach Überschrift oder Slug
Auflistung aller stabilen Spezifikationsversionen, die als GitHub-Tags verfügbar sind
Metadaten abrufen über die Spezifikation (Version, Quelle, Cache-Informationen, Größe)
Versionsbewusst — fragen Sie jede veröffentlichte Spezifikationsversion ab oder verwenden Sie standardmäßig die neueste
Caching — ETag/Last-Modified-basiertes HTTP-Caching mit einer 10-minütigen TTL bei Tag-Abfragen
Related MCP server: EasyPeasyMCP
Verwenden Sie den gehosteten Server auf Glama — keine lokale Einrichtung erforderlich. Fügen Sie Folgendes zu Ihrer MCP-Client-Konfiguration hinzu:
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}Siehe den Abschnitt Konfiguration weiter unten für client-spezifische Anweisungen.
Node.js v20 oder neuer
npm installnpm run buildStreamable HTTP (für die lokale Entwicklung):
npm run devDer Server startet standardmäßig unter http://localhost:3000/mcp. Setzen Sie die Umgebungsvariable PORT, um einen anderen Port zu verwenden:
PORT=8080 npm run devStdio (für die Bereitstellung):
npm startTool | Beschreibung | Parameter |
| Listet stabile AsyncAPI-Spezifikationsversionen auf, die als GitHub-Tags verfügbar sind | Keine |
| Gibt Quelle, Version, Cache- und Größen-Metadaten für eine Spezifikation zurück |
|
| Durchsucht die Spezifikation und gibt passende Snippets zurück |
|
| Validiert rohen AsyncAPI YAML- oder JSON-Inhalt und gibt Validierungsfehler zurück |
|
| Gibt einen Abschnitt anhand des Überschriftentextes oder Slugs zurück |
|
Ressource | URI | Beschreibung |
Neueste AsyncAPI-Spezifikation |
| Die neueste AsyncAPI-Markdown-Spezifikation vom Master-Branch |
AsyncAPI-Spezifikation nach Version |
| Eine spezifische Version der Spezifikation, abgerufen vom passenden GitHub-Release-Tag |
Verwenden Sie diese Konfigurationen, um eine Verbindung zum Glama-gehosteten Server herzustellen. Keine lokale Einrichtung erforderlich.
Hinzufügen zu ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) oder %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}Hinzufügen zu .cursor/mcp.json in Ihrem Projektstammverzeichnis:
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}Hinzufügen zu .vscode/mcp.json in Ihrem Projektstammverzeichnis:
{
"servers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp",
"type": "http"
}
}
}Hinzufügen zu Ihren Windsurf MCP-Einstellungen:
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}In den MCP-Einstellungen von Cline hinzufügen:
{
"mcpServers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}Hinzufügen zu Ihrer OpenCode-Konfiguration:
{
"mcp": {
"servers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}
}Hinzufügen zu Ihrer Zed settings.json:
{
"context_servers": {
"asyncapi": {
"url": "https://glama.ai/mcp/servers/Souvikns/asyncapi-mcp"
}
}
}Verwenden Sie diese Konfigurationen, wenn Sie den Server lokal mit npm run dev ausführen. Stellen Sie sicher, dass der Server läuft, bevor Sie eine Verbindung herstellen.
{
"mcpServers": {
"asyncapi": {
"url": "http://localhost:3000/mcp"
}
}
}{
"mcpServers": {
"asyncapi": {
"url": "http://localhost:3000/mcp"
}
}
}{
"servers": {
"asyncapi": {
"url": "http://localhost:3000/mcp",
"type": "http"
}
}
}Ersetzen Sie die Glama-URL in den obigen Konfigurationen durch http://localhost:3000/mcp.
Dieser Server wird auf Glama.ai bereitgestellt. Siehe glama.ai/mcp/servers/Souvikns/asyncapi-mcp für die gehostete Instanz.
Um Ihre eigene Instanz bereitzustellen, bauen Sie sie und führen Sie sie mit Stdio-Transport aus:
npm run build
npm startEin Dockerfile ist für containerisierte Bereitstellungen enthalten:
docker build -t asyncapi-mcp .
docker run -p 3000:3000 asyncapi-mcpSobald die Konfiguration abgeschlossen ist, können Sie Ihrem KI-Assistenten Fragen stellen wie:
"Was sagt die AsyncAPI-Spezifikation über Server-Objekte?"
"Durchsuche die AsyncAPI-Spezifikation nach 'channels'"
"Rufe den Abschnitt 'Info Object' aus Version 2.6.0 ab"
"Liste alle verfügbaren AsyncAPI-Spezifikationsversionen auf"
"Was sind die Unterschiede zwischen Nachrichten in AsyncAPI 2.x und 3.x?"
"Zeige mir den Spezifikationsabschnitt über Schema-Definitionen"
# 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.
