Developer tools#MCP

PushGo: self-hostable push notifications with an MCP gateway

PushGo splits push into messages, events and objects; its Rust gateway is self-hostable, speaks QUIC and MQTT 5, exposes MCP, and official apps exist.

Project facts

GitHub Ecosystem
Repositorygithub.com/AldenClark/pushgo-gateway
License
MIT
Language
Rust
Stars
39
Data checked
2026-10-14

Snapshot figures reflect the check date and may change over time.

Self-hosted push usually means ntfy or Gotify: a line of text lands on your phone, which works — until your alerts pile up and “which thing, what happened, does it need me” all depend on how well you word the title. PushGo structures the problem instead: a notification becomes one of three models — objects are the servers, NAS boxes or locks you watch, events are the state changes on them, and messages are the body delivered to a device. The gateway is written in Rust under MIT, and an official iOS/macOS/watchOS client is already on the App Store.

Core features

  • Messages, events, objects: the App Store positions it for “developers, DevOps users, self-hosting enthusiasts, NAS users, and smart home setups” — the object carries what is changing, the event carries how and whether it matters, and the message carries the body, so alerts stop being one-line riddles.
  • One gateway, four transports: beyond the public HTTP API (devices, channels, messages, events), private realtime transport runs on QUIC, raw TCP, WSS or MQTT 5 (QoS 1 only), enabled per deployment; MQTT downlink is a live outlet and is not persisted.
  • Persisted before it sends: downlink deliveries land in an application outbox first and clear only after acknowledgement (PUBACK), replaying on reconnect; senders get op_id idempotent retries — reusing an op_id with a different payload returns 409 — and /send_status/{op_id} for status; the default MQTT packet cap is 32KB (32,768 bytes).
  • MCP gateway built in: --mcp-enabled mounts /mcp with an OAuth flow on the same HTTP listener and supports predefined clients, so an AI assistant acting as an MCP client can bind to a channel and push directly.
  • Official clients on both platforms: the Apple client (iOS 17+/macOS 14+/watchOS 10+) is a signed App Store release with an active TestFlight, and Android ships as a Kotlin app on GitHub; the App Store listing says delivery goes over APNs with end-to-end encryption (E2EE).
  • Hosted or self-hosted: the hosted service has a global region (*.pushgo.dev) and a Mainland China region (*.pushgo.cn, and the default token service points there); self-hosting ships Docker Compose and systemd templates, starting on SQLite and moving to PostgreSQL/MySQL at scale.

Typical use cases

  • A home lab with a NAS, smart-home devices and a pile of scripts: devices become objects, anomalies become events, and the phone gets structured alerts instead of one-line guesses.
  • An operator running a handful of servers: alerts, progress and recovery notices stay grouped per object, and op_id retries mean a rerun script can’t double-bomb your phone.
  • Anyone whose AI agent should report in: once an MCP client binds a channel, a long-running agent can push its own progress at the moments that matter.

Quick start

The shortest path is installing PushGo from the App Store and pointing it at the hosted token service. For self-hosting, start from the pushgo-gateway README — Docker Compose and systemd templates live in the repo, and the minimal setup is PUSHGO_DB_URL (SQLite or Postgres/MySQL) plus --private-transports picking your transports (say quic,tcp,wss,mqtt; QUIC needs TLS certs).

Summary

For self-hosters and operators who care about “the message reliably arrived” above all. If you want a large community and ready-made tutorials, it’s early for that — as of 2026-10-14 the gateway has 39 stars, the Apple client 52, Android 10, and the README leans protocol-heavy. Gateway in Rust, clients in Swift and Kotlin, all three repos MIT.

Two things to know first: MQTT downlink is not persisted, so an offline MQTT receiver misses deliveries — reliable catch-up goes through the clients; and “end-to-end encryption” is currently the App Store listing’s wording, while the gateway README grounds its security in transport TLS and channel passwords — verify the encryption boundary yourself before trusting a self-hosted deployment. For another take on “messages arrive reliably”, Mailflare moves email onto your own Cloudflare account where PushGo moves events into your pocket.