Remote MCP Server Generator

Build your remote MCP server

#!/usr/bin/env node
import { createServer } from "node:http";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import { z } from "zod";

const PORT = Number(process.env.PORT ?? 8000);
// 127.0.0.1 for local use; set HOST=0.0.0.0 inside Docker or on a server.
const HOST = process.env.HOST ?? "127.0.0.1";
const list = (v: string | undefined) =>
  (v ?? "").split(",").map((s) => s.trim()).filter(Boolean);
// Host headers we answer (DNS rebinding protection). Add your public
// hostname, e.g. ALLOWED_HOSTS=mcp.example.com
const ALLOWED_HOSTS = new Set([
  `localhost:${PORT}`,
  `127.0.0.1:${PORT}`,
  ...list(process.env.ALLOWED_HOSTS),
]);
// Browser Origins allowed to call /mcp. Requests without Origin (CLI and
// desktop clients) are allowed.
const ALLOWED_ORIGINS = new Set(list(process.env.ALLOWED_ORIGINS));

function buildServer(): McpServer {
  const server = new McpServer({
    name: "weather-remote",
    version: "1.0.0",
  });

  server.registerTool(
    "get_weather",
    {
      description: "Get current weather for a city",
      inputSchema: z.object({
      city: z.string().describe("City name, e.g. San Francisco")
    }),
    },
    async ({ city }) => {
      // TODO: replace this placeholder with real logic for get_weather
      return {
        content: [{ type: "text", text: "[get_weather] " + "city=" + JSON.stringify(city) }],
      };
    }
  );

  return server;
}

const httpServer = createServer(async (req, res) => {
  const path = new URL(req.url ?? "/", "http://localhost").pathname;
  if (path === "/health") {
    res.writeHead(200, { "content-type": "text/plain" }).end("ok");
    return;
  }
  if (path !== "/mcp") {
    res.writeHead(404, { "content-type": "text/plain" }).end("Not found");
    return;
  }
  if (!ALLOWED_HOSTS.has(req.headers.host ?? "")) {
    res.writeHead(421, { "content-type": "text/plain" }).end("Invalid Host header");
    return;
  }
  const origin = req.headers.origin;
  if (origin && !ALLOWED_ORIGINS.has(origin)) {
    res.writeHead(403, { "content-type": "text/plain" }).end("Invalid Origin header");
    return;
  }
  // Stateless: a fresh server and transport for every request, so any
  // number of clients (or replicas behind a load balancer) can call it.
  const server = buildServer();
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined,
    enableJsonResponse: true,
  });
  res.on("close", () => {
    transport.close();
    server.close();
  });
  try {
    await server.connect(transport);
    await transport.handleRequest(req, res);
  } catch (err) {
    console.error(err);
    if (!res.headersSent) {
      res.writeHead(500, { "content-type": "text/plain" }).end("Internal server error");
    }
  }
});

httpServer.listen(PORT, HOST, () => {
  console.error(`weather-remote MCP server listening on http://${HOST}:${PORT}/mcp`);
});

What the remote MCP server ZIP contains

The stdio button gives you the same project as the home page generator (TypeScript) or the Python MCP server generator. If you start from an OpenAPI spec instead of a form, use the OpenAPI to MCP converter.

We ran both generated servers

On 2026-10-28 we generated a three-tool project (get_weather, add with a number, an optional number and a reserved-word boolean, and ping with no arguments) in both languages, started each with ALLOWED_HOSTS=mcp.example.com, and called it with curl and with the official TypeScript SDK client (StreamableHTTPClientTransport, the same transport Claude Code and other SDK-based clients use). TypeScript: Node 20.19.2, @modelcontextprotocol/sdk 1.32.2, tsc --strict clean. Python: 3.13.5, mcp 2.3.0, uvicorn 0.54.0.

The Dockerfiles follow the same commands but were not built in this run (no Docker engine on the test machine), so treat the first docker build as your own check.

Same check from your terminal, after npm start or python server.py:

curl -s http://127.0.0.1:8000/mcp \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2025-06-18' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

For the visual check, run npx @modelcontextprotocol/inspector, choose transport Streamable HTTP and enter the URL. More test recipes are in how to test an MCP server.

Deploy the remote MCP server

1. Build and run the container. docker build -t weather-remote . then docker run -p 8000:8000 -e ALLOWED_HOSTS=mcp.example.com weather-remote. Inside the container HOST is 0.0.0.0; on 127.0.0.1 the port mapping would have nothing to reach.
2. Give it HTTPS. Any container host works: a VM behind Caddy or nginx, Google Cloud Run, Fly.io, Railway, Render, AWS ECS or Kubernetes. Clients expect https://…/mcp; terminate TLS at the proxy or platform.
3. Allow your hostname. Set ALLOWED_HOSTS to the name clients use (comma-separated). The Python server also accepts name:* for any port. Make sure the proxy passes the public Host header through, or every request gets 421.
4. Add authentication before real data. The generated server has none. Use your platform's IAM (for example Cloud Run without unauthenticated access), a gateway or proxy that checks a bearer token, or MCP OAuth. How to test an OAuth-protected server is covered in testing MCP OAuth.
5. Replace the stubs. Every handler echoes its arguments with a TODO. For handlers that call a private REST API with a token and readable errors, copy the tested helpers from build an MCP server for an internal API.

Connect Claude Code, Cursor and VS Code to a remote MCP server

The MCP config generator writes and validates these files (including a bearer header and Codex TOML). For local stdio paths and troubleshooting, see connect an MCP server to Claude Desktop and Cursor.

Local stdio or remote HTTP: which one do you need?

• Stay on stdio when the tools are for you, on your machine: reading local files, running local commands, a personal API key. Nothing to host and nothing exposed.
• Go remote when a team, several machines, a hosted agent or a web app must use the same tools, when the tools live next to a database or service in your cloud, or when you do not want everyone to install Node or Python.
• Remote costs you hosting, TLS, authentication and monitoring. If you only need one person's editor to see the tools, stdio is simpler. New to the protocol? Start with what is an MCP server.

Limitations (honest)

• No authentication in the generated code; see the deploy steps.
• Stateless JSON only. No sessions, no SSE streams, no server-to-client notifications or resumable streams. Fine for tools; switch to a session-based setup if you need streaming progress.
• Tools only. No resources or prompts; the MCP server template guide shows how to add them.
• Simple parameter types (string, number, boolean). For enums, arrays, annotations or outputSchema, use the MCP tool schema generator.

FAQ