Use a runner (private networks)

Connect MCP servers inside your network or cluster without opening anything to the internet, and without giving sremcp their credentials.

Who can: Owners, Admins and SREs add runners. Everyone who sees the MCP servers sees them.

A runner is a small service you run next to your MCP servers: in a Kubernetes cluster, a VPC or a data center. It reaches the servers there, and only ever calls out to sremcp over HTTPS.

 Your network                                         sremcp
┌─────────────────────────────────────────┐          ┌──────────────────────────┐
│ Grafana MCP   Kubernetes MCP   DB MCP   │ outbound │ the agent, approvals,    │
│      ▲             ▲             ▲      │──HTTPS──▶│ roles, audit log         │
│      └──────── sremcp-runner ────┘      │   only   └──────────────────────────┘
│   (addresses and credentials stay here) │
└─────────────────────────────────────────┘
  • Credentials stay with you. The runner's config holds each server's credential (from an environment variable or a mounted secret). sremcp never receives it, nor the server's address: it knows the server by a name only.
  • Nothing inbound. No public endpoint, no VPN, no firewall change beyond letting the runner reach api.sremcp.com on port 443. It works through an HTTP proxy (HTTPS_PROXY).
  • Your rules come first. Per server, the runner can allow only some tools, deny others, or allow only read-only ones. It enforces them whatever sremcp asks: a hidden tool never reaches approval, and a call to it is refused.
  • You can audit and stop it. The runner logs every request as a JSON line for your log pipeline. Stop it, and sremcp's access stops with it.

What does leave your network

The agent's tool calls and their results (metric values, log lines, object specs): the agent reads them to investigate. The runner caps each result at about 1 MB.

Set one up

The quickest way is the form in sremcp: MCP servers → Runners → Add runner. You name the runner, say where it runs (Kubernetes or Docker) and describe its servers, and sremcp writes the manifest or commands to deploy it, with the runner's key filled in. It never asks for the servers' credentials: the one command that creates the secret has a placeholder for each, which you fill in on your own machine.

The steps below are the same thing by hand.

Add the runner in sremcp

Go to MCP servers → Runners → Add runner. Name it after the network it sits in, for example prod-eu.

sremcp shows the runner's key (srr_…) once. Keep it as a secret; it works like a password. If it's lost or leaked, New key replaces it, and the old one stops working at once.

Write its config

List each MCP server by the name sremcp will know it by, with its credential as ${AN_ENV_VAR} (or ${file:/path} for a mounted secret):

runner.yaml
servers:
  grafana:
    url: http://mcp-grafana.mcp.svc.cluster.local:8000/mcp
    headers:
      Authorization: Bearer ${GRAFANA_MCP_TOKEN}
    tools:
      allow: ["search_*", "query_*", "list_*", "get_*"]
  kubernetes:
    url: http://mcp-kubernetes.mcp.svc.cluster.local:8080/mcp
    readOnly: true
    tools:
      deny: ["pods_exec", "*_delete"]

A server that speaks stdio can be started by the runner itself (command: and args:). It gets only the environment you give it, never the runner's key.

Check it, then run it

sremcp-runner check --config runner.yaml

check connects to each server and lists the tools sremcp would see, and why the others are hidden. Then run the runner with its key:

docker run -d --restart unless-stopped \
  -v "$PWD/runner.yaml:/etc/sremcp-runner/runner.yaml:ro" \
  -e SREMCP_RUNNER_KEY -e GRAFANA_MCP_TOKEN \
  ghcr.io/sremcp/runner:0.1.0

In Kubernetes, use the runner's manifest: the key in a Secret, two replicas, no Service, and a NetworkPolicy that refuses all inbound traffic. Within seconds the runner shows online on the Runners page, with the servers it reports.

Onboard each server through it

MCP servers → Onboard server, then under Connection choose Through a runner: pick the runner, and the server's name in its config. From there it's the same as any server: test, approve tools, grant roles and activate.

Day to day

What you seeWhat it means
pendingThe runner hasn't connected with its key yet.
onlineIt asked sremcp for work within the last minute.
offlineNot heard from for a minute. Servers through it fail their health checks, and the people who manage servers get the usual is down notification.
  • Several networks: add a runner for each. Each server goes through one runner.
  • High availability: run two or more replicas with the same key. Each request goes to one of them.
  • Changing the config: restart the runner. New servers show on the Runners page once it reports them.
  • Removing a runner: delete the servers that go through it first, then the runner.

If sremcp refuses the runner's key (it was replaced, or the runner deleted), the runner logs why and exits, so your orchestrator shows it failing instead of it retrying quietly.

On this page