tutorial

Monitoring SillyTavern with Vigilmon

SillyTavern is the most popular self-hosted LLM chat frontend — but it's frontend-only, and its health depends on both the Node.js server and its configured LLM backend. Here's how to monitor both with Vigilmon.

SillyTavern is the most popular open-source LLM chat and roleplay frontend — a Node.js/Express application that connects to any OpenAI-compatible backend (KoboldCpp, Ollama, LM Studio, vLLM) or commercial API. Character cards, world books, group chats, memory management: it's a feature-rich interface that the local AI community has built their workflows around.

But SillyTavern is frontend-only — it has no inference engine of its own. That means it can fail in two distinct ways: the Node.js server itself can go down, or the LLM backend it connects to can become unreachable, leaving the UI running but unable to generate responses. Vigilmon monitors both layers, plus your character data filesystem and SSL certificates for HTTPS-proxied deployments.

What You'll Set Up

  • HTTP uptime monitor for the SillyTavern web UI (port 8000)
  • REST API health check for the /api/ping endpoint
  • Backend connectivity check via /api/backends/chat-completions/status
  • SSL certificate expiry alerts for HTTPS-proxied SillyTavern deployments
  • Heartbeat monitor for SillyTavern character data and filesystem availability

Prerequisites

  • SillyTavern running on Linux, Windows, or macOS (accessible at http://your-server:8000 or via a reverse proxy)
  • A free Vigilmon account

Step 1: Monitor the SillyTavern Web UI

SillyTavern serves its chat interface on port 8000 by default. This is your first health signal — if port 8000 goes down, the Node.js server has crashed or stopped.

  1. Log in to vigilmon.online and click Add Monitor.
  2. Set Type to HTTP / HTTPS.
  3. Enter the URL: http://your-server-ip:8000 (or https://st.yourdomain.com if behind a reverse proxy).
  4. Set Check interval to 1 minute.
  5. Set Expected HTTP status to 200.
  6. Click Save.

SillyTavern's default page (the login page or the main chat UI, depending on your auth settings) returns a 200. If the Node.js process crashes or the port binding drops, this monitor fires immediately.

Step 2: Monitor the /api/ping Health Endpoint

SillyTavern has a built-in health ping endpoint that confirms the Express server is accepting API requests:

GET http://your-server-ip:8000/api/ping

Response:

{ "pong": true }

This is a more reliable health signal than the homepage — the /api/ping route is lightweight, always returns JSON, and doesn't depend on frontend asset loading. Add a monitor:

  1. Click Add Monitor → HTTP / HTTPS.
  2. URL: http://your-server-ip:8000/api/ping
  3. Expected HTTP status: 200
  4. Response body contains: "pong"
  5. Check interval: 1 minute
  6. Click Save.

The body check on "pong" ensures you're hitting the real API and not a proxy error page returning a 200.

Step 3: Monitor the Backend Connectivity Status

SillyTavern's most insidious failure mode is when the server is healthy but the configured LLM backend is unreachable — you see the chat UI but every message fails with a connection error. The /api/backends/chat-completions/status endpoint exposes this:

GET http://your-server-ip:8000/api/backends/chat-completions/status

This endpoint returns the current backend connection status. Add a monitor for it:

  1. Click Add Monitor → HTTP / HTTPS.
  2. URL: http://your-server-ip:8000/api/backends/chat-completions/status
  3. Expected HTTP status: 200
  4. Check interval: 2 minutes
  5. Click Save.

Combine this with a monitor for your actual LLM backend (a KoboldCpp or Ollama health endpoint) to pinpoint whether a failure is in SillyTavern itself or its backend.

Step 4: SSL Certificate Alerts for HTTPS-Proxied Deployments

If you've placed SillyTavern behind nginx or Caddy with TLS, add certificate expiry monitoring. SillyTavern over the open internet without HTTPS exposes your character cards and chat history — a lapsed certificate is a real security gap.

  1. Open the HTTP monitor you created in Step 1 (your HTTPS URL).
  2. Enable Monitor SSL certificate in the SSL section.
  3. Set Alert when certificate expires in less than 21 days.
  4. Click Save.

A typical nginx reverse proxy config for SillyTavern:

server {
    listen 443 ssl;
    server_name st.yourdomain.com;

    ssl_certificate /etc/letsencrypt/live/st.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/st.yourdomain.com/privkey.pem;

    # Increase timeouts for long LLM generation
    proxy_read_timeout 600s;
    proxy_send_timeout 600s;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
    }
}

The 21-day alert window gives you time to investigate and resolve Let's Encrypt renewal failures before the certificate expires.

Step 5: Heartbeat Monitoring for Character Data Availability

SillyTavern stores all character cards, chat histories, world books, and lorebooks as JSON files on disk. If the filesystem unmounts (common with NAS storage or external drives) or the data directory becomes inaccessible, SillyTavern continues running but all your characters and chat history disappear from the UI.

Use Vigilmon's heartbeat monitor with SillyTavern's /api/characters/all endpoint to confirm the data layer is accessible:

  1. In Vigilmon, click Add Monitor → Cron Heartbeat.
  2. Set the expected ping interval to 10 minutes.
  3. Copy the heartbeat URL: https://vigilmon.online/heartbeat/YOUR_KEY

Add a cron job on your server that polls the characters endpoint and pings Vigilmon only when data is accessible:

#!/bin/bash
# sillytavern-data-check.sh
# Run via cron every 5 minutes

HEARTBEAT_URL="https://vigilmon.online/heartbeat/YOUR_KEY"
CHARACTERS_URL="http://localhost:8000/api/characters/all"

RESPONSE=$(curl -s --max-time 10 "$CHARACTERS_URL" 2>/dev/null)
STATUS=$?

# Check curl succeeded and we got a JSON array response (not an error page)
if [ $STATUS -eq 0 ] && echo "$RESPONSE" | grep -q '\['; then
    curl -s "$HEARTBEAT_URL"
fi

Add to crontab:

*/5 * * * * /home/user/sillytavern-data-check.sh

If the /api/characters/all endpoint fails — because the data directory is unmounted, the JSON files are corrupted, or the SillyTavern process can't access the filesystem — the heartbeat stops and Vigilmon alerts after 10 minutes.

Step 6: Configure Alert Channels

  1. Go to Alert Channels in Vigilmon and add Slack, Discord, email, or a webhook.
  2. Assign the alert channel to all monitors.
  3. For the web UI monitor, set Consecutive failures before alert to 2 — brief Node.js hiccups shouldn't immediately page you.
  4. For the backend status monitor, set consecutive failures to 1 — a single failure here means users can't get responses.

Summary

| Monitor | Target | What It Catches | |---|---|---| | Web UI | http://your-server:8000 | Node.js server crash, port binding failure | | API ping | /api/ping | Express server health | | Backend status | /api/backends/chat-completions/status | LLM backend unreachable | | SSL certificate | HTTPS domain | Let's Encrypt renewal failure | | Cron heartbeat | /api/characters/all | Filesystem unmount, data directory inaccessible |

SillyTavern's power comes from the ecosystem it connects — characters, backends, extensions, data files. With Vigilmon watching every layer, you'll know the moment any part of that stack goes down, whether it's the Node.js server, the LLM backend, or the filesystem holding your character library.

Get started free at vigilmon.online — no credit card, monitors start running in under a minute.

Monitor your app with Vigilmon

Free plan — 5 monitors, no credit card required. Up and running in 60 seconds.

Start free →
← Back to all articles