Self-Hosted AI Agent: Complete Setup with Docker & Monitoring

┌─────────────────────────────────────────────────┐
│                  Your Network                    │
│                                                  │
│  ┌──────────────────────────────────────────┐   │
│  │           Docker Compose Stack            │   │
│  │                                           │   │
│  │  ┌─────────────┐  ┌─────────────────┐   │   │
│  │  │  OpenClaw    │  │   Prometheus    │   │   │
│  │  │  Gateway     │  │   (metrics)     │   │   │
│  │  │  :18789      │  │   :9090         │   │   │
│  │  └──────┬───────┘  └────────┬────────┘   │   │
│  │         │                    │             │   │
│  │  ┌──────┴───────┐  ┌───────┴─────────┐   │   │
│  │  │  Agent       │  │   Grafana       │   │   │
│  │  │  Workspaces  │  │   (dashboards)  │   │   │
│  │  │  (volumes)   │  │   :3000         │   │   │
│  │  └──────────────┘  └─────────────────┘   │   │
│  │                                           │   │
│  │  ┌─────────────────────────────────┐     │   │
│  │  │  Watchdog (health + alerting)   │     │   │
│  │  └─────────────────────────────────┘     │   │
│  └──────────────────────────────────────────┘   │
│                                                  │
│  Telegram / Slack / Discord  ←──→  AI APIs       │
└─────────────────────────────────────────────────┘

FROM node:22-slim

# Install OpenClaw globally
RUN npm install -g openclaw

# Create app directory
WORKDIR /app

# Copy agent configurations
COPY agents/ /app/agents/

# Copy entrypoint script
COPY entrypoint.sh /app/entrypoint.sh
RUN chmod +x /app/entrypoint.sh

# Expose gateway port
EXPOSE 18789

# Health check endpoint
HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
  CMD curl -f http://localhost:18789/health || exit 1

ENTRYPOINT ["/app/entrypoint.sh"]

#!/bin/bash
# entrypoint.sh

# Initialize OpenClaw if first run
if [ ! -f /data/.initialized ]; then
  openclaw init
  touch /data/.initialized
fi

# Register agents from /app/agents/
for agent_dir in /app/agents/*/; do
  agent_name=$(basename "$agent_dir")
  if [ -f "$agent_dir/SOUL.md" ]; then
    openclaw agents add "$agent_name" \
      --workspace "$agent_dir" --non-interactive 2>/dev/null || true
  fi
done

# Configure AI provider from environment variable
if [ -n "$ANTHROPIC_API_KEY" ]; then
  openclaw models auth paste-token \
    --provider anthropic --token "$ANTHROPIC_API_KEY"
fi

# Start the gateway
exec openclaw gateway start

version: "3.8"

services:
  openclaw:
    build: .
    container_name: openclaw-gateway
    restart: unless-stopped
    ports:
      - "18789:18789"
    volumes:
      - openclaw-data:/data
      - ./agents:/app/agents:ro
    environment:
      - NODE_ENV=production
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN}
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:18789/health"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 15s
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  prometheus:
    image: prom/prometheus:latest
    container_name: openclaw-prometheus
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus-data:/prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.retention.time=30d"

  grafana:
    image: grafana/grafana:latest
    container_name: openclaw-grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD:-changeme}
      - GF_USERS_ALLOW_SIGN_UP=false

  watchdog:
    build:
      context: .
      dockerfile: Dockerfile.watchdog
    container_name: openclaw-watchdog
    restart: unless-stopped
    environment:
      - HEALTH_URL=http://openclaw:18789/health
      - CHECK_INTERVAL=60
      - ALERT_TELEGRAM_TOKEN=${TELEGRAM_BOT_TOKEN}
      - ALERT_CHAT_ID=${ALERT_CHAT_ID}
    depends_on:
      openclaw:
        condition: service_healthy

volumes:
  openclaw-data:
  prometheus-data:
  grafana-data:

# .env - keep this file out of version control
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxxxxxxxxxx
TELEGRAM_BOT_TOKEN=123456:ABC-DEF-your-bot-token
ALERT_CHAT_ID=your-telegram-chat-id
GRAFANA_PASSWORD=your-secure-password

# Build and start everything
docker compose up -d --build

# Check container status
docker compose ps

# View gateway logs
docker compose logs -f openclaw

# Verify health endpoint
curl http://localhost:18789/health

# monitoring/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: "openclaw"
    static_configs:
      - targets: ["openclaw:18789"]
    metrics_path: /metrics
    scrape_interval: 15s

  - job_name: "node-exporter"
    static_configs:
      - targets: ["host.docker.internal:9100"]

#!/bin/bash
# watchdog.sh - Agent health monitor with Telegram alerting

HEALTH_URL="${HEALTH_URL:-http://localhost:18789/health}"
CHECK_INTERVAL="${CHECK_INTERVAL:-60}"
FAIL_THRESHOLD=3
TELEGRAM_TOKEN="${ALERT_TELEGRAM_TOKEN}"
CHAT_ID="${ALERT_CHAT_ID}"

fail_count=0
last_alert_time=0
ALERT_COOLDOWN=300  # 5 minutes between repeated alerts

send_alert() {
  local message="$1"
  if [ -n "$TELEGRAM_TOKEN" ] && [ -n "$CHAT_ID" ]; then
    curl -s -X POST \
      "https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage" \
      -d "chat_id=${CHAT_ID}" \
      -d "text=${message}" \
      -d "parse_mode=HTML" > /dev/null
  fi
  echo "[ALERT] $message"
}

echo "[watchdog] Monitoring $HEALTH_URL every ${CHECK_INTERVAL}s"

while true; do
  http_code=$(curl -s -o /dev/null -w "%{http_code}" \
    --max-time 5 "$HEALTH_URL" 2>/dev/null)

  if [ "$http_code" = "200" ]; then
    if [ $fail_count -ge $FAIL_THRESHOLD ]; then
      send_alert "OpenClaw gateway recovered. Status: OK"
    fi
    fail_count=0
  else
    fail_count=$((fail_count + 1))
    echo "[watchdog] Health check failed ($http_code) - count $fail_count/$FAIL_THRESHOLD"

    if [ $fail_count -ge $FAIL_THRESHOLD ]; then
      now=$(date +%s)
      diff=$((now - last_alert_time))
      if [ $diff -ge $ALERT_COOLDOWN ]; then
        send_alert "OpenClaw gateway is DOWN. Host: $(hostname). Status: $http_code. Failed checks: $fail_count. Time: $(date -u '+%Y-%m-%d %H:%M UTC')"
        last_alert_time=$now
      fi
    fi
  fi

  sleep "$CHECK_INTERVAL"
done

# Dockerfile.watchdog
FROM alpine:3.19
RUN apk add --no-cache bash curl
COPY watchdog.sh /watchdog.sh
RUN chmod +x /watchdog.sh
CMD ["/watchdog.sh"]

What the monitoring stack gives you

# Add Watchtower for automatic image updates
# Append to your docker-compose.yml services:

  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_CLEANUP=true
      - WATCHTOWER_SCHEDULE=0 0 4 * * *  # Check daily at 4 AM
      - WATCHTOWER_NOTIFICATIONS=shoutrrr
      - WATCHTOWER_NOTIFICATION_URL=telegram://${TELEGRAM_BOT_TOKEN}@telegram?channels=${ALERT_CHAT_ID}