Monitoring Open WebUI with Vigilmon: LLM Interface Availability, Ollama Backend Health & SSL Alerts

Open WebUI is a self-hosted ChatGPT-style interface that runs on top of Ollama, giving you a polished chat UI for local LLMs without sending data to any cloud provider. It's increasingly used in enterprise and research settings where privacy matters. But Open WebUI has two failure points instead of one: the web UI itself, and the Ollama backend it depends on for model inference. Vigilmon lets you monitor both layers independently, so you know exactly what broke when users can't chat.

What You'll Build

• An HTTP monitor on Open WebUI's /health endpoint
• A web UI availability check for the chat interface
• A monitor for Ollama API connectivity (the backend Open WebUI depends on)
• SSL certificate monitoring for your Open WebUI domain
• Response time tracking for model inference latency

Prerequisites

• Open WebUI running (default port 3000, or behind a reverse proxy)
• Ollama running on the same or a connected machine (default port 11434)
• A domain with HTTPS configured (recommended)
• A free account at vigilmon.online

Step 1: Check Open WebUI's Health Endpoint

Open WebUI exposes a /health endpoint that returns a simple status response when the application is running:

curl https://chat.yourdomain.com/health
# {"status":true}

Test directly on the default port if not behind a reverse proxy:

curl http://localhost:3000/health

A {"status":true} response confirms Open WebUI's Python backend (FastAPI) is running and accepting connections.

Step 2: Create the Health Monitor in Vigilmon

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://chat.yourdomain.com/health
3. Check interval: 60 seconds.
4. Response timeout: 10 seconds.
5. Expected status: 200.
6. Keyword: true (matches the {"status":true} response).
7. Click Save.

This monitor catches:

• Open WebUI process crashes or restarts
• Database connection failures (if the backend can't reach SQLite/PostgreSQL, health returns unhealthy)
• Reverse proxy routing failures
• Container crashes (if running via Docker)

Step 3: Monitor the Chat UI Availability

The /health endpoint checks the application process, but the actual user interface is what matters to users. Add a separate monitor for the main page:

1. Add Monitor → HTTP.
2. URL: https://chat.yourdomain.com/
3. Expected status: 200.
4. Keyword: Open WebUI (present in the page title).
5. Check interval: 120 seconds.

This catches static asset failures, build issues, or cases where the backend is up but the frontend isn't being served correctly.

Step 4: Monitor Ollama API Connectivity

Open WebUI is only as useful as the Ollama backend it connects to. If Ollama crashes or becomes unreachable, every chat request in Open WebUI returns an error. Monitor Ollama's API health directly:

curl http://localhost:11434/api/tags
# Returns JSON list of loaded models

If Ollama is exposed through a reverse proxy or on a separate machine:

1. Add Monitor → HTTP.
2. URL: https://ollama.yourdomain.com/api/tags (or your Ollama endpoint).
3. Expected status: 200.
4. Keyword: models (the response includes a "models" array).
5. Check interval: 60 seconds.

If Ollama is internal only: Set up a cron-based heartbeat (see Step 6) on the host machine to probe localhost:11434/api/tags and push the result to Vigilmon.

Step 5: Monitor SSL Certificate for Your Chat Domain

Open WebUI handles user conversations and potentially API keys. An expired certificate forces users to bypass browser security warnings or disables the service entirely in strict browser policies.

1. Add Monitor → SSL Certificate.
2. Domain: chat.yourdomain.com
3. Alert when expiry is within: 30 days.
4. Alert again: 14 days, 7 days, 3 days.

If you're also exposing Ollama externally via HTTPS, add a second SSL monitor for that domain.

Step 6: Track Model Inference Response Time

LLM inference is inherently slow, but baseline latency varies significantly based on model size and GPU availability. Setting response time thresholds helps you catch when inference is degrading — often a sign of memory pressure, GPU throttling, or another process consuming resources.

Use the existing HTTP monitor on /health for infrastructure response time. For inference latency specifically, set up a heartbeat probe:

#!/bin/bash
# /etc/cron.d/open-webui-inference-heartbeat
# Runs every 10 minutes

# Quick Ollama inference probe
RESPONSE=$(curl -s -X POST http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{"model":"tinyllama","prompt":"ping","stream":false}' \
  --max-time 30)

if echo "$RESPONSE" | grep -q "response"; then
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-HEARTBEAT-ID
fi

Create a Heartbeat monitor with a 20-minute expected interval and 30-minute grace period. If inference becomes completely stuck (common when a model runs out of VRAM and starts OOM-killing), the heartbeat stops and you get alerted.

Step 7: Configure Alerting

In Vigilmon under Settings → Notifications, configure your alert channels:

| Monitor | Trigger | First action | |---|---|---| | Open WebUI /health | Non-200 or keyword missing | docker restart open-webui or systemctl restart open-webui | | Chat UI page | Non-200 | Check reverse proxy logs; verify container is running | | Ollama /api/tags | Non-200 | systemctl restart ollama; check GPU/VRAM status | | SSL certificate | < 30 days | Run certbot renew or check Caddy ACME logs | | Inference heartbeat | Missed > 30 min | Check ollama ps; look for OOM kills in dmesg |

Alert after 2 consecutive failures for HTTP monitors; alert after 1 missed heartbeat for the inference probe (inference failures are immediately impactful).

Common Open WebUI Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Open WebUI container crashes | Health endpoint fails within 60 s | | Ollama runs out of VRAM and exits | /api/tags monitor fires; heartbeat stops | | Model not loaded (cold start delay) | Response time alert catches extended latency | | SSL certificate expires | SSL monitor alerts at 30 days | | Reverse proxy loses connection to Open WebUI | UI monitor fires; health monitor may still pass | | Database corruption → Open WebUI unhealthy | Health endpoint returns non-200 | | Ollama API version mismatch after update | Open WebUI shows errors; /api/tags check still passes |

Open WebUI's privacy-preserving approach to AI chat makes it a compelling alternative to cloud LLM services — but self-hosting means you own the reliability too. With Vigilmon watching both the web interface and the Ollama backend, you'll know within a minute whether a problem is in the chat layer, the inference engine, or the SSL certificate, so you can fix it before users notice.

Start monitoring Open WebUI in under 5 minutes — register free at vigilmon.online.