Announcements

Deploy Any MCP: stdio Bridge Support Now Available

By DeployContext Team•

We're excited to announce stdio bridge support on DeployContext. You can now deploy any Model Context Protocol server, including stdio-based MCPs, without modifying your code.

The Problem

Most MCP servers use stdio transport—they're designed to run locally as subprocesses. But cloud deployment requires HTTP/SSE endpoints. Previously, you'd need to rewrite your MCP to support HTTP/SSE.

The Solution: Automatic Bridging

DeployContext now automatically bridges stdio MCPs to HTTP/SSE. The bridge is completely invisible—your MCP works exactly as before, but now it's accessible over the web.

Architecture Diagram

Here's how the stdio bridge works:

                    ┌─────────────────┐
                    │     Client      │
                    │ (Claude, API)   │
                    └────────┬────────┘
                             │
                    HTTP/SSE │
                    (web)    │
                             ▼
        ┌──────────────────────────────────────┐
        │        Bridge Service                │
        │   (Automatic & Invisible)            │
        │                                      │
        │  • Converts HTTP/SSE ↔ stdio         │
        │  • Manages sessions                   │
        │  • Handles process lifecycle         │
        └──────────────┬───────────────────────┘
                       │
              stdio    │
              (local)  │
                       ▼
        ┌──────────────────────────┐
        │      stdio MCP           │
        │  (npx, uvx command)      │
        │                          │
        │  Your MCP runs here      │
        │  No code changes needed!  │
        └──────────────────────────┘

Key Point: The bridge automatically handles the conversion between HTTP/SSE (what clients need) and stdio (what your MCP uses). You never interact with the bridge—it just works.

How It Works

When you deploy a stdio-based MCP:

  1. Automatic Detection - We detect that your MCP uses stdio transport
  2. Bridge Wrapper - We automatically wrap it in a bridge service
  3. HTTP/SSE Endpoints - The bridge exposes standard HTTP/SSE endpoints
  4. Transparent Operation - Your MCP code doesn't change at all

The bridge handles:

  • Spawning the MCP process
  • Converting HTTP requests to stdio messages
  • Converting stdio responses to SSE events
  • Session management
  • Automatic process restart on failures

What This Unlocks

Official MCP Packages

You can now deploy all official @modelcontextprotocol packages:

  • @modelcontextprotocol/server-puppeteer - Browser automation
  • @modelcontextprotocol/server-filesystem - File operations
  • @modelcontextprotocol/server-postgres - Database queries
  • @modelcontextprotocol/server-github - GitHub integration
  • And many more...

Community MCPs

Hundreds of community MCPs that were previously stdio-only can now be deployed:

  • Any npm package with npx command
  • Python packages via uvx (coming soon)
  • Custom MCPs from GitHub

Example: Deploying Puppeteer MCP

Previously, deploying the official Puppeteer MCP required rewriting it for HTTP/SSE. Now it's as simple as:

  1. Deploy from GitHub - Point to the official repo, or
  2. Deploy from npm - Use the package name directly

The bridge automatically:

  • Runs npx @modelcontextprotocol/server-puppeteer
  • Wraps it in HTTP/SSE endpoints
  • Makes it accessible at your endpoint URL

No code changes needed.

Technical Details

Transport Detection

DeployContext automatically detects transport mode:

  • Native HTTP/SSE - MCPs with built-in HTTP support deploy directly
  • stdio - Automatically bridged (invisible to you)
  • SSE Flag - MCPs that support --transport sse flag

Bridge Architecture

The bridge is a lightweight Node.js service that:

  • Spawns your MCP as a subprocess
  • Manages stdin/stdout communication
  • Exposes HTTP/SSE endpoints
  • Handles session management
  • Automatically restarts on crashes

Supported Runtimes

  • Node.js stdio MCPs - Via npx command
  • Python stdio MCPs - Via uvx command (coming soon)

Impact

Based on our analysis of 150+ MCPs from cursor.directory:

  • 58% use stdio transport → Now deployable
  • 14% support SSE flag → Already supported
  • 28% are native HTTP/SSE → Already supported

Result: You can now deploy 94%+ of all MCPs on DeployContext.

Getting Started

  1. Deploy a stdio MCP - Just point to the GitHub repo or npm package
  2. Automatic bridging - We handle the rest
  3. Use it - Access via HTTP/SSE endpoint, just like native MCPs

👉 **Deploy your first stdio MCP** - It works exactly like deploying any other MCP.

What's Next?

We're continuing to improve stdio bridge support:

  • Python uvx support for Python stdio MCPs
  • Enhanced error handling and logging
  • Performance optimizations
  • Support for more package managers

Learn More

Questions? Contact support.

← Back to Blog