View all articles
MonitoringUptime KumaPrometheusSelf-hostingLocal AI

Keep a Local AI Server Running: Uptime Kuma and Prometheus

JG
Jacobo González Jaspe
|
Abstract illustration: stepped platforms with a small amber light on the highest one. Desde la spark
Illustration generated with AI on our own machine.
This article is also available in Spanish:Tu servidor de IA local, vigilado: Uptime Kuma y Prometheus

By the end of this post you will have Uptime Kuma checking every AI service on your machine and Prometheus alerting on memory, with the commands we use. It runs on anything that runs Docker; a used mini PC is enough for the monitoring itself.

We are also going to show you our own month of history, including the part that is embarrassing. That part is the most useful one.

What you need

  • A machine running your models (Ollama, vLLM or similar) and Docker
  • 30 minutes
  • A phone app or chat you already read (Telegram, ntfy, email) for notifications

What we run, and what a month of it showed

Our reference box is a DGX Spark (GB10, 128 GB unified memory) with a second Spark on a direct cable. On it run Uptime Kuma 1.23.17 (louislam/uptime-kuma:1, on port 3003) and Prometheus 3.5.4 (port 9092) with node-exporter, cAdvisor and utkuozdemir/nvidia_gpu_exporter.

We pulled 30 days of history on 2026-10-08 with scripts/bench/monitoring_history.py, which reads Prometheus’ ALERTS series through /api/v1/query_range and a copy of the Uptime Kuma database. Raw output is in monitoring-history-2026-10-08.json.

Alert (Prometheus, DGX Spark, 8 Sep to 8 Oct 2026)EpisodesHours firing
Second Spark unreachable17100.0
Second Spark GPU exporter down12102.6
Second Spark under 15 GB free31.8
Main Spark under 8 GB free40.3
LiteLLM gateway down00

The memory alerts were short: the longest lasted 1.5 hours. We did not note the cause of each “unreachable” episode while it happened, and a month later we cannot say which were planned reboots. Write one line per alert when it fires; it is the cheapest habit in this post.

Uptime Kuma, same window, showed the less flattering half:

  • Zero monitors linked to a notification. A notification channel existed. No monitor used it. Every outage above was visible only to whoever opened the dashboard.
  • Three monitors red for the whole month. Two checked a path that answered 404 on every beat. The third, Uptime Kuma checking itself, timed out on every beat.
  • The public-site checks failed mostly on DNS inside the container (getaddrinfo ENOTFOUND), not because the sites were down.
  • A moved service broke its monitor. When our vLLM moved to the second Spark on 5 October, the local forwarder listened on 127.0.0.1 only, so the container saw “connection refused” and then timeouts. The check was red for the last three days of the window.

Prometheus has the same gap: /api/v1/alertmanagers returns an empty list, so its alerts fire into its own web page and nowhere else. A monitor nobody hears is a log file.

Step 1: run Uptime Kuma

bash
docker run -d --name uptime-kuma --restart=unless-stopped \
  -p 3003:3001 -v uptime_kuma_data:/app/data \
  --add-host host.docker.internal:host-gateway \
  louislam/uptime-kuma:1

Open http://localhost:3003 and create the admin account. The --add-host line lets the container reach services on the host as host.docker.internal. We map 3003 because 3001 was taken; use any free port.

Step 2: add monitors that check the right thing

Before you add a monitor, test the exact URL from inside the container. This one command would have saved us the three red monitors:

bash
docker exec uptime-kuma curl -s -o /dev/null -w "%{http_code}\n" \
  http://host.docker.internal:11434/api/tags

Expect 200. A 404 means the path is wrong; “connection refused” means the service listens on 127.0.0.1 only and the container cannot reach it.

Health paths that answer 200 on our stack:

ServiceURL to checkInterval
Ollamahttp://host.docker.internal:11434/api/tags30 s
LiteLLMhttp://host.docker.internal:4000/health/readiness30 s
vLLMhttp://<vllm-host>:8200/health30 s
Open WebUIhttp://host.docker.internal:300060 s
Qdranthttp://host.docker.internal:6333/healthz60 s
Uptime Kuma itselfhttp://localhost:3001/ (inside the container)60 s

Set “Retries” to 2 or 3 for model servers. A large model load can block a health check for a few seconds, and one missed beat is not an outage.

This is the step we skipped. In Settings, Notifications, add a channel you actually read. Then open each monitor, tick that notification, and save. Tick “Default enabled” on the channel so new monitors get it automatically.

Test it: stop a service on purpose and wait for the message. Wait longer than the interval times (retries + 1): with 60 s and 3 retries, that is four minutes.

bash
docker stop open-webui && sleep 300 && docker start open-webui

If your phone stays silent, your monitoring is not finished.

Step 4: let Prometheus watch memory and the gateway

Uptime Kuma sees HTTP. Prometheus sees the machine. Our prometheus.yml scrapes node-exporter, cAdvisor and the GPU exporter every 15 seconds and loads one rules file. These are three of our six rules, shortened (we dropped the labels and annotations):

YAML
groups:
  - name: gateway
    rules:
      - alert: LiteLLMGatewayDown
        expr: up{job="litellm"} == 0
        for: 3m
  - name: machines
    rules:
      - alert: PrimeMemoryCritical
        expr: node_memory_MemAvailable_bytes{job="node"} < 8e9
        for: 10m
      - alert: AssistantSparkDown
        expr: up{job="spark2-node"} == 0
        for: 5m

Why memory from the node exporter and not the GPU exporter? On the GB10 the GPU exporter reports temperature, power and utilisation, but no “memory used”: the memory is shared with the CPU. On a card with its own VRAM you would alert on the GPU memory metric instead.

Check that every target is up:

bash
curl -s localhost:9092/api/v1/targets | python3 -c \
 "import sys,json;[print(t['labels']['job'],t['health']) for t in json.load(sys.stdin)['data']['activeTargets']]"

Step 5: wire Alertmanager (our next step, not done yet)

Prometheus only evaluates rules; Alertmanager delivers them. We have not deployed it yet, so we will not pretend to show you a tested config. The Prometheus configuration docs show the alerting: block you add to prometheus.yml. Until then, Uptime Kuma with notifications covers “it is down”, which is the alert that matters most.

A 10-minute weekly routine

bash
curl -s localhost:9092/api/v1/alerts            # anything firing right now?
docker ps --filter health=unhealthy             # containers failing their own checks
ollama ps                                       # what is loaded, and how big

Then open Uptime Kuma and look for any monitor that has been red for more than a day. Fix it or delete it. A monitor that is always red teaches you to ignore red.

When not to bother

  • One model on a laptop, used by you alone. You will notice when it stops. Skip all of this.
  • A team relies on it. Then you need Step 3 at least, today.

Next steps

If you would rather have someone else watch the server for your company, that is the kind of work we do: book a 15-minute call or see how we work in consulting.

Diagram
Share: LinkedIn X
Veredicto semanal

Get new guides before anyone else

Subscribe and we tell you when new guides, templates and workflows go up. One email a week, no spam.

Already published: 102 guides and 25 templates. All free, no signup.

Bonus: the local-AI starter pack PDF when you subscribe
Once a week No spam Unsubscribe anytime

See what you get