🚌🚇 SG Bus + Train — a Muse connector

Real-time Singapore bus arrival times and MRT/LRT service info as an MCP server, powered by the official LTA DataMall API. Ask in plain language:

"When is the next bus 96 at stop 83139?" "Which buses stop at Buona Vista?" "Is the next bus 151 wheelchair accessible?" "What buses are near me?" "Is the MRT disrupted right now?" "How crowded is Dhoby Ghaut station?" "Which stations are on the Circle Line?"

Built for submission to the Meta Muse connector directory (muse.ai/platform).

How it works

Muse ──MCP (streamable HTTP)──▶ this server ──HTTPS──▶ LTA DataMall API
                                      │                        ▲
                                      └─ forwards YOUR key ────┘

Auth model (per-user keys, with a demo fallback)

This connector uses API keys auth:

• Each end user ideally brings their own free LTA DataMall API key (from https://datamall.lta.gov.sg — sign up, free).

• The user saves the key in Muse as the x-lta-account-key request header (alias accountkey also accepted). Own keys are unlimited.

• For try-before-you-commit, the server can be configured with a demo key via the LTA_DEMO_ACCOUNT_KEY env var (the developer's own key, shared quota). Callers without their own key fall back to it, rate-limited to 10 calls per client IP per day (in-memory). When the budget is exhausted they get a friendly error pointing at the free key signup.

• The server never stores any key — yours or the demo one — and never logs keys.

Tools (all read-only)

Bus stop codes are validated as exactly 5 digits. LTA calls have a 10s timeout with 2 retries (exponential backoff), per-call latency logging, and human-readable errors — agents surface these directly to users.

Bundled static data (no cold starts)

Reference data that changes rarely lives in data/*.json, committed to the repo, loaded from disk on first use and kept in memory afterwards:

This means bus_route, find_bus_stops, nearby_bus_stops and train_stations answer instantly — even the very first call after a deploy — with zero LTA traffic. Only genuinely live data (arrivals, alerts, crowding) hits the LTA API per request. If a bundled file is ever missing, the server falls back to a live LTA fetch so a partial checkout still works.

Tool outputs note the snapshot date (e.g. "Route data bundled 2026-09-25"), so agents can see the vintage. To refresh the bus datasets:

python3 scripts/refresh_static_data.py   # uses the sg-bus CLI + stored credential
git add data/bus_stops.json data/bus_routes.json && git commit -m "Refresh bus datasets"

scripts/build_train_stations.py rebuilds the station map from its upstream source (re-run when new stations open).

Static pages

The same app serves three pages (needed for directory submission):

• / — product landing: what it is, example prompts, key signup link, connect instructions

• /privacy — plain language: keys forwarded per-request to LTA only, nothing stored, no analytics

• /terms — as-is, not affiliated with LTA or Meta

Related MCP server: Singapore Location Intelligence MCP

Local dev

python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
uvicorn server:app --reload
# → http://127.0.0.1:8000/        (landing page)
# → http://127.0.0.1:8000/mcp     (MCP endpoint)

No LTA key is needed to start the server or list tool schemas — only actual bus queries need a key.

Deploy

Fly.io

fly launch --no-deploy        # accepts the existing fly.toml
fly deploy
fly open                      # your public URL, e.g. https://sg-bus-mcp.fly.dev

Optional — enable the demo fallback: fly secrets set LTA_DEMO_ACCOUNT_KEY=<your-key> (use your own DataMall key; the shared quota is yours to mind).

Region is sin (closest to LTA's API). Machines scale to zero when idle.

Render

1. Push this repo to GitHub.

2. In Render: New → Blueprint and point it at the repo (it picks up render.yaml).

3. Done — Render builds the Dockerfile and gives you a public URL.

Optional — enable the demo fallback by adding an LTA_DEMO_ACCOUNT_KEY environment variable (marked secret) in the Render dashboard.

Region is singapore; Render injects $PORT, which the Dockerfile already listens on.

Connect from Muse (custom connector)

1. In Muse: Connectors → Add custom connector.

2. MCP server URL: https://<your-deployed-host>/mcp

3. API key: either save your free LTA DataMall key as the x-lta-account-key request header — or skip it and try the shared demo key (10 free tries a day, no signup).

4. Ask: "When is the next bus 96 at stop 83139?"

Submission checklist (muse.ai/platform)

• Public HTTPS endpoint serving the MCP server at /mcp

• Product landing page at / with example prompts and key signup link

• /privacy and /terms pages

• Auth documented: per-user LTA keys via x-lta-account-key header, nothing stored server-side

• Demo fallback documented (developer's shared key, 10 tries/day/IP, own key for unlimited use)

• Read-only tools (no writes, no spending, no side effects)

• Human-readable error messages for every failure mode

• Health check: GET / returns 200

• Live end-to-end test with a real LTA key (needs a key — see below)

• Privacy/terms reviewed by a human before submission

⚠️ Not yet tested live: the code paths that call LTA (bus_arrivals with a valid key, and the first find_bus_stops cache load) have not been exercised against the real API — no LTA key was available during development. Run one manual bus_arrivals call with a real key before submitting.

License

MIT — see LICENSE. Not affiliated with LTA or Meta.