Skip to main content
asyncmcp is currently in alpha. APIs may change as we refine the implementation based on community feedback.What’s not supported yet:
  • Direct integration with standard MCP clients (Claude, Cursor, etc.) without using the proxy server. All MCP servers will only work with standard clients through the asyncmcp proxy bridge.
  • Advanced features like sampling, elicitation are not supported on all transports.

​
What is asyncmcp?

asyncmcp provides custom asynchronous transport layers for the Model Context Protocol (MCP), enabling MCP servers to handle requests through queues, topics, and webhooks rather than requiring immediate responses through standard stdio or HTTP transports.

MCP Server working over AWS SQS queues

​
Why Async Transports?

Traditional MCP transports (stdio, HTTP) require synchronous request-response patterns. However, many real-world contexts aren’t immediately available:

Batch Processing

APIs that process data in batches and return results later

Webhooks

Services that notify through webhooks when processing completes

Queue Systems

Message queues that decouple producers from consumers

Long Operations

Tasks that take minutes or hours to complete

​
Supported Transports

  • SQS
  • SNS+SQS
  • Webhook
  • StreamableHTTP+Webhook
AWS Simple Queue Service - Point-to-point messaging
  • Direct queue-to-queue communication
  • Guaranteed message delivery
  • Simple, cost-effective for basic async needs

​
How to use asyncmcp

The approach depends on whether you control the client implementation:

​
You Control the Client

If you’re building your own client application, you can directly use asyncmcp transports:
  1. Choose a transport based on your requirements:
    • SQS: Simple queue-based async, ideal for basic request-response patterns
    • SNS+SQS: Topic-based routing for multiple subscribers or fanout scenarios
    • Webhook: HTTP-based async for web services and existing infrastructure
    • StreamableHTTP+Webhook: Hybrid approach for mixed sync/async operations
  2. Implement both sides using the matching transport client and server
  3. See examples in the Quick Example section below or browse the Examples documentation

​
You Don’t Control the Client

If you’re working with standard MCP clients (Claude, Cursor, etc.) that only support stdio/HTTP:
  1. Use the asyncmcp proxy server to bridge between standard and async transports
  2. The proxy translates standard MCP requests to your chosen async transport
  3. Learn more in the Proxy Server documentation

​
Quick Example

Here’s how simple it is to create an MCP server with async SQS transport: 
import boto3
from asyncmcp.sqs import sqs_server
from asyncmcp import SqsServerConfig
from mcp.server.lowlevel import Server

# Configure transport
config = SqsServerConfig(
    read_queue_url="https://sqs.region.amazonaws.com/account/requests"
)

# Create MCP server
app = Server("my-async-server")

# Add your tools
@app.call_tool()
async def process_data(name: str, arguments: dict):
    # Long-running operation
    result = await process_large_dataset(arguments["data"])
    return [{"type": "text", "text": str(result)}]

# Run with SQS transport
async def main():
    sqs_client = boto3.client('sqs')
    async with sqs_server(config, sqs_client) as (read, write):
        await app.run(read, write, InitializationOptions())

​
Getting Started

Quickstart

Install asyncmcp and get started with your first server

Transports

Explore available transports

Examples

Browse working examples for each transport type

Proxy Server

Bridge standard MCP clients with async transports

​
Community & Support

​
License

asyncmcp is open source software licensed under the Apache License 2.0.
⌘I