Monitoring Karakeep with Vigilmon: Uptime, Health Checks & AI Service Alerts for Your Self-Hosted Bookmark Manager

Karakeep (formerly Hoarder) is a self-hosted bookmark and read-it-later app with an AI twist — it automatically tags your saved links and articles using OpenAI or a local Ollama instance. It's the kind of tool that becomes deeply embedded in your daily workflow, which makes its availability critical. But self-hosting means you're responsible for keeping it running. If the Node.js server crashes, the SQLite database gets corrupted, or the AI tagging backend goes offline, your bookmarks stop syncing and tags stop appearing. Vigilmon gives you external uptime monitoring that watches Karakeep from outside your server and alerts you the moment something fails.

What You'll Build

• A Vigilmon HTTP monitor on Karakeep's /api/health endpoint
• A keyword assertion to confirm the backend is genuinely healthy
• A heartbeat monitor to verify SQLite database accessibility
• An AI service connectivity heartbeat (OpenAI or Ollama)
• SSL certificate expiry alerts (if running behind a reverse proxy)

Prerequisites

• A running Karakeep instance accessible over HTTPS (reverse proxy with Caddy or Nginx recommended)
• A free account at vigilmon.online

Step 1: Verify Karakeep's Health Endpoint

Karakeep exposes a health check endpoint at /api/health on port :3000 (the default). This endpoint is active on every Karakeep installation without configuration.

curl https://your-karakeep-domain.com/api/health

A healthy Karakeep instance returns HTTP 200:

{"status":"ok"}

If the Node.js process has crashed, the connection will be refused. If the database is locked or inaccessible, the endpoint may return 503.

HTTPS setup: Run Karakeep behind a reverse proxy with TLS. Caddy handles this automatically:

your-domain.com {
  reverse_proxy localhost:3000
}

Step 2: Create an HTTP Monitor in Vigilmon

1. Log in to Vigilmon → Add Monitor → HTTP.
2. URL: https://your-karakeep-domain.com/api/health.
3. Check interval: 60 seconds.
4. Response timeout: 15 seconds.
5. Expected status: 200.
6. Click Save.

Vigilmon starts probing your Karakeep health endpoint every 60 seconds from an external location. If the process crashes or becomes unresponsive, you'll know within 60–120 seconds.

Step 3: Add a Keyword Assertion

A 200 status confirms the HTTP layer responded, but not that Karakeep's internals are functional. Add a keyword assertion to verify the response body.

In the same monitor:

• Keyword: ok
• Keyword must be present: yes

This catches scenarios where a misconfigured reverse proxy intercepts the request and returns an HTML error page with a 200 status code — something that looks fine from a status-code perspective but means users can't actually access their bookmarks.

Step 4: Monitor SQLite Database Accessibility

Karakeep uses SQLite to store bookmarks, tags, and user data. SQLite is a single file — it can become locked, corrupted, or inaccessible if the disk fills up or if an interrupted write leaves it in a bad state. The health endpoint may not surface these issues directly.

Create a Heartbeat monitor in Vigilmon:

1. Add Monitor → Heartbeat.
2. Name: Karakeep SQLite heartbeat.
3. Expected ping interval: 5 minutes.
4. Grace period: 2 minutes.
5. Copy the generated heartbeat URL.

Add a cron job that runs a direct SQLite query against Karakeep's database file:

# /etc/cron.d/karakeep-db-heartbeat
*/5 * * * * root \
  sqlite3 /data/karakeep/hoarder.db "SELECT COUNT(*) FROM bookmarks LIMIT 1" > /dev/null 2>&1 && \
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-HEARTBEAT-ID

Adjust the path /data/karakeep/hoarder.db to match your Karakeep data directory (check HOARDER_SERVER_DATA_DIR in your environment config).

If the SQLite file becomes locked, corrupted, or the disk fills up, the sqlite3 command fails, the heartbeat stops pinging, and Vigilmon alerts you within 7 minutes.

Step 5: Monitor AI Tagging Service Connectivity

Karakeep's AI auto-tagging is one of its standout features. It connects to either:

• OpenAI (api.openai.com) for cloud-based tagging
• Ollama (default port :11434) for fully local, private AI tagging

If the AI service goes offline, new bookmarks won't get tags — but Karakeep itself continues running and the health endpoint still returns 200. You'll only notice the issue when you open a saved link and find it untagged.

For Ollama (local):

# /etc/cron.d/karakeep-ollama-heartbeat
*/5 * * * * root \
  curl -sf http://localhost:11434/api/tags > /dev/null 2>&1 && \
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-OLLAMA-HEARTBEAT-ID

This checks that Ollama's API is responding and listing available models. If Ollama crashes or gets OOM-killed (LLM inference is memory-intensive), the heartbeat stops.

For OpenAI (cloud):

OpenAI connectivity is harder to monitor directly since it requires authentication. The practical approach is to check for network reachability:

# /etc/cron.d/karakeep-openai-heartbeat
*/5 * * * * root \
  curl -sf --max-time 5 https://api.openai.com > /dev/null 2>&1 && \
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-OPENAI-HEARTBEAT-ID

This confirms your server can reach OpenAI's API endpoint. If your VPS has egress filtering or OpenAI has an outage, this heartbeat catches it.

Step 6: SSL Certificate Monitoring

Add an SSL monitor to get alerted before your certificate expires:

1. Add Monitor → SSL Certificate.
2. Domain: your-karakeep-domain.com.
3. Alert when: certificate expires within 14 days.

An expired certificate causes browser security warnings that prevent access to the app entirely. Since Karakeep may be running quietly in the background without daily attention, this monitor ensures you don't miss a renewal failure.

Step 7: Configure Alerting

In Vigilmon under Settings → Notifications:

| Trigger | Channel | Action | |---|---|---| | /api/health returns non-200 | Email + Slack | Restart: systemctl restart karakeep | | Response timeout (> 15 s) | Email | Check Node.js logs: journalctl -u karakeep -n 50 | | Keyword ok missing | Email | Check reverse proxy; inspect raw response | | SQLite heartbeat misses | Email | Check disk: df -h; inspect DB file integrity | | Ollama heartbeat misses | Email | Restart Ollama: systemctl restart ollama | | OpenAI heartbeat misses | Email | Check egress rules; verify API key validity | | SSL expires within 14 days | Email | Run certbot renew or check Caddy renewal logs |

Alert after: 1 consecutive failure for the health endpoint. Use 2 consecutive failures for AI service heartbeats to avoid false alerts from brief network hiccups.

Running Karakeep as a systemd Service

For VPS deployments using the binary or Node.js directly:

# /etc/systemd/system/karakeep.service
[Unit]
Description=Karakeep Bookmark Manager
After=network.target

[Service]
Type=simple
User=karakeep
WorkingDirectory=/opt/karakeep
EnvironmentFile=/opt/karakeep/.env
ExecStart=/usr/bin/node /opt/karakeep/apps/web/server.js
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now karakeep

For Docker deployments, use docker compose with restart: unless-stopped and wrap the heartbeat cron around docker exec:

# /etc/cron.d/karakeep-db-heartbeat-docker
*/5 * * * * root \
  docker exec karakeep sqlite3 /data/hoarder.db "SELECT 1" > /dev/null 2>&1 && \
  curl -fsS -X POST https://vigilmon.online/api/heartbeat/YOUR-HEARTBEAT-ID

What Vigilmon Catches That App Logs Miss

| Scenario | App logs | Vigilmon | |---|---|---| | Node.js process crash | May log before exit | HTTP monitor fires within 60–120 s | | SQLite file locked or corrupted | DB error on write | SQLite heartbeat stops; alert fires | | Ollama OOM-killed by kernel | Kernel log only | Ollama heartbeat stops; alert fires | | OpenAI API unreachable (egress block) | AI worker error logs | OpenAI heartbeat stops; alert fires | | SSL certificate expired | Nothing logged | SSL monitor alerts 14 days early | | VPS unreachable from internet | Logs inaccessible | External Vigilmon still detecting outage |

Karakeep turns web bookmarking from a cluttered tab graveyard into a searchable, AI-tagged knowledge base — but only when it's running. Vigilmon makes sure you're the first to know when it's not, with independent monitoring of every layer that matters: the web server, the database, the AI backend, and the SSL certificate.

Start monitoring your Karakeep instance in under 5 minutes — register free at vigilmon.online.