MCP Server Deployment Monitoring and Live Status Badges

Overview

The MCP (Model Context Protocol) Server provides deployment monitoring and live-status badges for AI assistants and model rollouts. It tracks deployment metadata, health checks, and runtime events so engineering teams can observe rollouts in real time, expose status badges for README pages, and feed dashboards or CI pipelines with up-to-date health signals.

This server is useful when you operate multiple assistant instances, A/B experiments, or staged rollouts and need a lightweight, standardized service to collect health probes, surface deployment state, and broadcast live events (via Server-Sent Events or WebSocket). It is designed for easy integration into CI/CD pipelines and documentation (badges), and to give on-call engineers a single endpoint to query deployment status.

Features

• Real-time tracking of deployment lifecycle events (start, ready, error, shutdown)
• Endpoint to generate live status badges (SVG) for READMEs and dashboards
• Health-check aggregation across instances and regions
• Server-Sent Events (SSE) and WebSocket support for live streams
• Simple REST API for registering deployments and reporting status
• Configurable persistence (in-memory or backed by a database)
• Authentication support via API keys or tokens
• Lightweight Docker and Kubernetes friendly deployment

Installation / Configuration

Requirements: Go or Node runtime (depending on implementation), or Docker.

Quick start with Docker:

# Run with default settings (in-memory store) - exposes port 8080
docker run -p 8080:8080 ghcr.io/alexpota/deploy-mcp:latest

Environment variables (example):

# Server
PORT=8080
LOG_LEVEL=info

# Security
MCP_API_KEY=changeme

# Persistence (optional)
STORE_TYPE=memory           # options: memory | sqlite | postgres
DATABASE_URL=postgres://user:pass@db:5432/mcp

# Badge options
BADGE_TEMPLATE=default

Docker Compose example:

version: "3.8"
services:
  mcp:
    image: ghcr.io/alexpota/deploy-mcp:latest
    ports:
      - "8080:8080"
    environment:
      - PORT=8080
      - MCP_API_KEY=${MCP_API_KEY}
      - STORE_TYPE=postgres
      - DATABASE_URL=${DATABASE_URL}
    depends_on:
      - postgres

  postgres:
    image: postgres:15
    environment:
      - POSTGRES_USER=mcp
      - POSTGRES_PASSWORD=mcp
      - POSTGRES_DB=mcp
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

Kubernetes deployment (minimal):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mcp
  template:
    metadata:
      labels:
        app: mcp
    spec:
      containers:
      - name: mcp
        image: ghcr.io/alexpota/deploy-mcp:latest
        env:
        - name: PORT
          value: "8080"
        - name: MCP_API_KEY
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: api-key
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: mcp
spec:
  type: ClusterIP
  ports:
  - port: 8080
  selector:
    app: mcp

Available Resources

API endpoints (examples)

Example request to register a deployment:

curl -X POST "http://localhost:8080/api/v1/deployments" \
  -H "Authorization: Bearer ${MCP_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "id": "assistant-production-v2",
    "version": "v2.1.0",
    "region": "us-west-2",
    "status": "starting",
    "metadata": {"replicas": 4}
  }'

Subscribing to live events (SSE):

curl -N "http://localhost:8080/api/v1/events?watch=assistant-production-v2" \
  -H "Authorization: Bearer ${MCP_API_KEY}"

Badge usage (embed in README):

[![assistant status](https://mcp.example.com/api/v1/badge/assistant-production-v2.svg)](https://mcp.example.com)

Use Cases

• Deployment README badges: Show an up-to-date badge in a repository README that reflects the latest health of a model rollout (green for healthy, yellow for degraded, red for failed).
• Real-time operations dashboard: Use SSE or WebSocket to pipe deployment events into a web dashboard that displays rolling logs, status transitions, and region availability.
• CI/CD gating: During canary deployments, have CI poll the MCP API to decide whether to promote a canary to production based on aggregated health signals captured by MCP.
• Incident response: On-call tooling can consume the /events stream to display which assistant instances reported errors, and surface context (version, region, uptime) in alerting UIs.
• Multi-region rollouts: Aggregate health checks from instances across regions and present a single “overall” status that considers regional failures.

Implementation Notes & Tips

• Authentication: Protect write endpoints (register/update) with API keys or OAuth tokens. Read-only badge endpoints can be public if you want badges to be visible in external READMEs.
• Persistence: For transient experiments, the memory store is easiest. For production monitoring, back the MCP server with a durable store (Postgres/SQLite) so historical events and last-known states persist across restarts.
• Badge caching: Serve badges with short caching headers (e.g., 30–60 seconds) to avoid heavy load if badges are included in many READMEs or dashboards.
• Scaling: Run multiple MCP instances behind a load balancer; use the database or a shared message bus (Redis/ Kafka) to synchronize state and broadcast events.

For developers new to MCP, start by running the Docker container locally, register a test deployment, and embed the badge in a README to validate end-to-end behavior before connecting production assistants.