Use Streamable HTTP to expose one authenticated HTTPS endpoint, usually https://your-domain.example/mcp, and run an MCP server process behind it. A production implementation needs four things: an explicit tool/resource contract, an official MCP SDK, origin and identity checks, and a deployment that handles the protocol revision you have selected. The current published transport (2025-11-25) defines one MCP endpoint supporting POST and GET; the 2026-07-28 draft moves toward POST with optional per-request SSE and removes the GET stream endpoint and protocol-level sessions.
What a remote MCP server is
A remote MCP server is an independently running process that accepts Model Context Protocol requests over HTTPS. Clients such as desktop assistants, IDEs, or agent frameworks connect to a stable URL instead of launching a local child process. The server advertises tools, resources, and prompts, validates inputs, performs permitted work against your systems, and returns structured MCP results.
Choose and pin a protocol revision before implementation. With the 2025-11-25 transport, one endpoint must support both POST and GET. POST carries client requests; GET can establish a server-to-client event stream. The 2026-07-28 draft changes that model: POST is the core request path, SSE is optional and scoped to a request, the GET stream endpoint is removed, and protocol-level sessions disappear. A client and server should therefore agree on the revision and SDK behavior rather than assuming that an older session-oriented deployment will work unchanged.
Plan the server contract before writing transport code
Inventory capabilities
- List every tool, resource, and prompt the server will expose.
- Mark operations as read-only or mutating.
- Document the downstream API, required identity, and minimum scope for each operation.
- Define explicit input and output schemas, including limits for strings, arrays, files, and pagination.
Separate policy from implementation
Authentication answers who is calling; authorization answers what that identity may do. Keep authorization checks next to the operation that uses the credential, not only in a global middleware layer. Reject malformed or out-of-range arguments before calling a downstream service, and return an actionable MCP error without exposing tokens or internal stack traces.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →#1 Best Overall
Choose an official SDK
Use the official TypeScript SDK for a Node.js service or the official Python SDK for Python. The TypeScript documentation identifies Streamable HTTP as the recommended remote transport. The Python deployment documentation provides a streamable_http_app integration and discusses worker counts and transport-security behavior. Pin the SDK version in your lockfile and read its transport notes when changing protocol revisions.
Build a minimal Python server
The following FastMCP example defines a tool and starts Streamable HTTP. Install the Python SDK in a virtual environment, save the file as server.py, and run it with Python.
python -m venv .venv
. .venv/bin/activate
pip install mcp
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("Example remote server")
@mcp.tool()
def add(a: int, b: int) -> int:
"""Add two integers."""
return a + b
@mcp.resource("config://service")
def service_config() -> str:
"""A non-secret service description."""
return "environment=production"
if __name__ == "__main__":
mcp.run(transport="streamable-http")
Start it with python server.py. Configure the SDK’s host, port, and MCP path for your release; advertise the resulting public path as a single URL such as https://api.example.com/mcp. Do not expose the development listener directly to the Internet. Put it behind TLS termination and an authentication-aware reverse proxy, or use the SDK’s application factory with equivalent middleware.
Build the same shape in TypeScript
The TypeScript SDK’s API evolves, so pin the package version and follow that version’s Streamable HTTP example. This skeleton shows the important pieces: one MCP server, an explicit tool schema, and one /mcp route. Run it behind a proxy that supplies HTTPS, authentication, and origin filtering.
npm install @modelcontextprotocol/sdk express zod
import express from "express";
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
const server = new McpServer({ name: "Example remote server", version: "1.0.0" });
server.tool(
"add",
"Add two integers",
{ a: z.number().int(), b: z.number().int() },
async ({ a, b }) => ({ content: [{ type: "text", text: String(a + b) }] })
);
const app = express();
app.use(express.json({ limit: "1mb" }));
app.post("/mcp", async (req, res) => {
const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
await server.connect(transport);
await transport.handleRequest(req, res, req.body);
});
app.listen(8080, "127.0.0.1", () => console.log("MCP listening on 127.0.0.1:8080/mcp"));
Match the transport constructor and request-handling signature to the SDK version you pin. If you select an earlier session-based revision, use the SDK’s documented session configuration and make sure every load-balanced worker can reach the required shared state.
Expose one HTTPS MCP endpoint
Use a stable public URL
Choose one route, commonly /mcp, and keep it stable. Terminate TLS at your edge proxy or in the service. Forward the request body, relevant headers, response status, and (when using the selected revision) SSE streaming without buffering. Set explicit body-size, idle-timeout, and upstream-timeout limits appropriate to your tools.
Rank #2
- HTML CSS Design and Build Web Sites
- Comes with secure packaging
- It can be a gift option
Test the endpoint through the same edge clients will use
- Resolve the public DNS name and verify its certificate.
- Send a request from an allowed Origin and confirm the expected MCP response.
- Send the same request with a missing or disallowed Origin; it must be rejected with HTTP 403.
- Verify that an unauthenticated request cannot invoke a tool.
- Exercise a slow downstream operation and confirm that the proxy and SDK timeouts produce a controlled error.
Secure every connection
Validate Origin on every request
The transport specification requires servers to validate the Origin header on all incoming connections to prevent DNS-rebinding attacks. Maintain an allowlist of exact origins for your clients, reject absent or invalid values according to your client policy, and return HTTP 403 for a value that is not allowed. Do not replace this check with a permissive wildcard.
Bind local listeners safely
Development and internal listeners should bind to 127.0.0.1, not 0.0.0.0. Expose the service publicly only through a deliberate edge or load-balancer configuration with TLS and firewall rules.
Authenticate and authorize all clients
Require authentication for every connection, including read-only tools. Use the downstream platform’s API-token or OAuth mechanism where appropriate, and issue credentials with only the scopes required by the advertised operations. Rotate and revoke credentials, reject expired tokens, and never write Authorization headers, cookies, or full request bodies to logs.
Protect mutating tools
For destructive operations, require narrower scopes and validate resource ownership or tenancy. Add idempotency keys where retries could duplicate a change. Return a request identifier so an operator can correlate a failure without revealing sensitive data.
Deploy the service
| Model | When it fits | Trade-offs to plan |
|---|---|---|
| Compiled binary on a VM | Small service with control over the operating system and network | You manage patching, process supervision, TLS, scaling, and failover. |
| Docker or another container engine | Repeatable builds and deployment across environments | Define health checks, graceful shutdown, resource limits, secret injection, and image updates. |
| Managed container task such as Fargate | Teams that want cloud scheduling without managing hosts | Configure task identity, load balancing, logs, timeouts, and private-network access. |
| Managed edge platform | Global routing and less infrastructure administration | Check runtime limits, streaming support, authentication integration, data locality, and vendor-specific behavior. |
HashiCorp’s remote MCP deployment guidance notes that the essential transport setting is streamable-http; its examples cover cloud, container, and Fargate environments, API-token authentication, and optional metrics. Cloudflare’s remote MCP guide demonstrates a managed edge deployment with authenticated and unauthenticated choices. Select the platform only after checking that it preserves your chosen protocol revision’s request and streaming behavior.
State, workers, and scaling
Determine whether your pinned protocol and SDK use protocol-level sessions. The 2025-11-25 model can involve a GET event stream and session handling; the 2026-07-28 draft removes protocol sessions and the GET stream endpoint. A stateless POST-oriented service is easier to distribute across workers, while sessionful behavior requires a consistent session store or routing strategy.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #3
- Set worker counts from measured CPU, memory, downstream rate limits, and concurrent connections rather than copying a default.
- Use connection and request timeouts that exceed normal downstream latency but cap stuck work.
- Keep shared state in an external store when the selected SDK requires it; do not assume in-process memory is shared between workers.
- Apply backpressure and per-identity rate limits before downstream services become the bottleneck.
Observability and operations
Expose a health check that verifies process readiness without invoking a destructive tool. Record request IDs, authenticated principal IDs, tool names, latency, response class, downstream status, rejected origins, and authentication failures. Redact arguments that may contain personal data or secrets. Add metrics for request count, error count, latency percentiles, active streams, and downstream throttling. HashiCorp lists metrics as an optional remote-deployment setting; treat them as essential once multiple clients depend on the service.
Release checklist
- Protocol revision and SDK version are pinned and documented.
- Only the intended HTTPS route is public.
- Origin allowlist and HTTP 403 behavior are tested.
- Authentication, scopes, rotation, and revocation are tested.
- Health checks, graceful shutdown, logs, and alerts are configured.
- Load-balancer timeout and streaming behavior are verified with the real client types.
Publish discovery metadata
Create a server.json file containing the server name, title, description, version, and a remote entry. The MCP Registry expects remote servers to be publicly reachable at the declared URL and recommends Streamable HTTP.
{
"name": "com.example.tools",
"title": "Example tools",
"description": "Read-only utilities for the example service.",
"version": "1.0.0",
"remotes": [
{
"type": "streamable-http",
"url": "https://api.example.com/mcp"
}
]
}
Do not publish a localhost, private-network, or temporary URL. Update the version and metadata when the public contract changes, and ensure the registry URL exactly matches the route clients can reach.
Or skip the browser setup
If your MCP server needs website screenshots, ScreenshotNeo provides a website screenshot API and an MCP server for AI agents. It accepts consent banners before capture and removes more than 60 known consent platforms, newsletter popups, and chat widgets; each step can be disabled. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed, and response headers identify the page verdict and billing status.
One request returns PNG, JPEG, WebP, or PDF:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo API documentation for all options, including full-page and selector capture, device presets, dark mode, custom CSS and JavaScript, headers, cookies, blocking rules, caching, signed links, asynchronous webhooks, bulk capture, and PDF controls. Python:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);Its MCP server exposes take_screenshot, get_page_info, and capture_pdf to Claude, Cursor, and other MCP clients. The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.
Troubleshooting
HTTP 403 on every request
Check the exact Origin value sent by the client, including scheme and port, against your allowlist. Confirm that a proxy is not replacing or dropping the header. A deliberately invalid Origin should be the only case that receives this response.
Rank #4
- Brand: Wiley
- Set of 2 Volumes
- A handy two-book set that uniquely combines related technologies Highly visual format and accessible language makes these books highly effective learning tools Perfect for beginning web designers and front-end developers
Client cannot connect or reports an unsupported transport
Confirm that client and server target the same protocol revision. An older client may expect GET-based event streaming or sessions that a draft POST-only implementation removed. Verify the public path, TLS certificate, proxy method forwarding, and SDK transport configuration.
Recommended Free Tools
Authentication succeeds but a tool is denied
Inspect the token’s audience, expiry, tenant, and scopes. Then check the tool-level authorization rule and downstream credential. Return a stable permission error while keeping the detailed reason in redacted server logs.
Requests hang behind a proxy
Disable response buffering for streaming routes, raise idle timeouts, and ensure the proxy forwards connection-close and content-type headers. Test a slow tool through the public URL, not only against localhost.
Works with one worker but fails after scaling
You likely have session or state affinity that is local to one process. Follow the SDK’s deployment guidance: use a shared state store, configure consistent routing, or adopt a stateless request model compatible with your selected revision.
Registry rejects the listing
Check that server.json uses type set to streamable-http, that the URL is publicly reachable over HTTPS, and that the advertised path is the single MCP endpoint rather than a health or documentation route.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11FAQ
Should the MCP endpoint have separate URLs for tools and resources?
No. The transport contract calls for one MCP endpoint path; expose capabilities through that endpoint and use ordinary application routes only for health checks or administration.
Can an internal-only server be listed in the public registry?
No. Registry metadata for a remote server must point to a publicly accessible URL. Keep private deployments in your organization’s client configuration instead.
Which hosting model is universally best?
None. Choose based on protocol compatibility, authentication, state, concurrency, observability, network controls, data locality, portability, and the operational work your team can support.
Frequently Asked Questions
Should the MCP endpoint have separate URLs for tools and resources?
No. Use one MCP endpoint path and reserve other routes for health checks or administration.
Free tools Windows power users keep installed
One-click scans. No signup required.
Can an internal-only server be listed in the public registry?
No. A registry remote URL must be publicly accessible; keep private servers in your organization’s client configuration.
Which hosting model is universally best?
There is no universal choice; evaluate protocol compatibility, security, state, scaling, observability, networking, and operational ownership.
The Bottom Line
A dependable remote MCP server is a small, explicit contract behind one HTTPS Streamable HTTP endpoint, protected by Origin validation and scoped authentication, deployed with state and worker behavior that matches its protocol revision, and described by reachable server.json metadata.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errors
