Monitoring Qdrant with Vigilmon: Collection Health, Query Latency, Shard Replication & AI/ML Uptime Checks

Qdrant is the vector database at the heart of modern AI/ML applications — powering semantic search, recommendation engines, and retrieval-augmented generation (RAG) pipelines. When Qdrant goes down or a collection becomes unavailable, your LLM-backed features silently degrade: queries return empty results, embeddings fail to persist, and reranking pipelines stall. Vigilmon gives you external visibility into Qdrant's health API, collection status, and query readiness before your users feel the impact.

What You'll Build

• A monitor on Qdrant's /healthz and /readyz endpoints for process-level liveness
• Collection-level health checks via the REST API
• Keyword-based alerting on shard replication status
• SSL certificate monitoring for your Qdrant endpoint
• Alerting thresholds that distinguish collection degradation from full outages

Prerequisites

• A running Qdrant instance (self-hosted or Qdrant Cloud) with REST API access on port 6333
• An accessible endpoint (e.g., https://qdrant.example.com)
• A free account at vigilmon.online

Step 1: Verify Qdrant's Health Endpoints

Qdrant exposes two standard health endpoints:

# Liveness — is the process running?
curl https://qdrant.example.com/healthz

# Readiness — is the node ready to serve requests?
curl https://qdrant.example.com/readyz

A healthy node returns HTTP 200 with body { "title": "qdrant - vector search engine", "version": "..." } from /healthz and an empty 200 from /readyz when fully initialized.

You can also query the cluster telemetry endpoint to get deeper operational data:

curl https://qdrant.example.com/telemetry

This returns JSON with collections count, request counts by type, and latency histograms.

Authentication: Qdrant supports API key auth. Pass it as a header: curl -H "api-key: YOUR_KEY" https://qdrant.example.com/healthz. For Qdrant Cloud, the API key is mandatory.

Step 2: Create a Vigilmon Liveness Monitor

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

This catches the most critical scenario: the Qdrant process is down or unreachable, which immediately breaks all embedding storage and vector search operations in your AI application.

Step 3: Monitor Collection Health

Collections are Qdrant's primary organizational unit — each collection holds a set of vectors for a specific embedding model or use case. Monitor critical collections via the collections API:

curl https://qdrant.example.com/collections/my-embeddings

A healthy collection returns:

{
  "result": {
    "status": "green",
    "optimizer_status": "ok",
    "vectors_count": 1500000,
    "indexed_vectors_count": 1500000,
    "points_count": 1500000,
    "segments_count": 8
  }
}

The status field signals collection health:

• green: All vectors indexed, all segments healthy
• yellow: Optimization in progress (temporary; expected after bulk uploads)
• red: Segment corruption or replication failure (data may be unavailable)

Add a Vigilmon monitor per critical collection:

1. Add Monitor → HTTP.
2. URL: https://qdrant.example.com/collections/my-embeddings.
3. Check interval: 2 minutes.
4. Expected status: 200.
5. Keyword: "green".
6. Label: Qdrant collection: my-embeddings.

Step 4: Monitor Shard Replication Status

For distributed Qdrant deployments, monitor shard replication to ensure your data is protected:

curl https://qdrant.example.com/collections/my-embeddings/cluster

This returns per-shard placement and replication factor:

{
  "result": {
    "peer_id": 12345,
    "shard_count": 4,
    "local_shards": [
      { "shard_id": 0, "state": "Active" },
      { "shard_id": 1, "state": "Active" }
    ],
    "remote_shards": [
      { "shard_id": 2, "remote_pending_operations": 0 }
    ]
  }
}

Add a monitor that catches non-Active shard states:

1. Add Monitor → HTTP.
2. URL: https://qdrant.example.com/collections/my-embeddings/cluster.
3. Check interval: 2 minutes.
4. Expected status: 200.
5. Keyword: "Active" — alert when absent (means no shards reporting Active state).
6. Label: Qdrant shard replication: my-embeddings.

Step 5: Monitor Indexing Throughput via Points Count

For AI/ML pipelines that continuously ingest embeddings, track vector counts to detect ingestion stalls:

curl https://qdrant.example.com/collections/my-embeddings

Check points_count vs indexed_vectors_count. A large and growing gap indicates the optimizer can't keep up with ingestion — a common sign of CPU saturation or memory pressure.

Add a dedicated monitor:

1. Add Monitor → HTTP.
2. URL: https://qdrant.example.com/collections/my-embeddings.
3. Check interval: 5 minutes.
4. Keyword: "optimizer_status":"ok" — alerts when optimizer is stuck.
5. Label: Qdrant optimizer status: my-embeddings.

Step 6: Monitor Query Latency via Telemetry

Qdrant's /telemetry endpoint exposes request latency percentiles and operation counts:

curl https://qdrant.example.com/telemetry

Look for the requests section which contains counters and error rates. Create a monitor that ensures the telemetry endpoint remains responsive (a proxy for overall node health):

1. Add Monitor → HTTP.
2. URL: https://qdrant.example.com/telemetry.
3. Check interval: 2 minutes.
4. Expected status: 200.
5. Response timeout: 5 seconds — a slow telemetry response indicates node-wide latency spikes.
6. Label: Qdrant telemetry latency sentinel.

Step 7: SSL Certificate Monitoring

1. Add Monitor → SSL Certificate.
2. Domain: qdrant.example.com.
3. Alert when expiry is within: 30 days.
4. Click Save.

Vector search endpoints are typically called from ML inference pipelines and AI frameworks like LangChain or LlamaIndex. A certificate expiry breaks these integrations silently with TLS handshake errors that are hard to diagnose at scale.

Step 8: Configure Alert Routing

In Vigilmon under Settings → Notifications:

| Monitor | Trigger | Action | |---|---|---| | /healthz liveness | Process unreachable | Escalate immediately; all vector search is down | | Collection health | Status not green | Check optimizer load; inspect segment logs | | Shard replication | No Active shards | Check cluster peer connectivity | | Optimizer status | optimizer_status not ok | Check CPU/memory; reduce ingestion rate | | Telemetry latency | Response > 5 s | Check node load; scale horizontally | | SSL certificate | < 30 days to expiry | Renew certificate; check cert-manager |

Alert after: 1 consecutive failure for liveness monitors, 2 for collection and shard monitors (brief yellow states occur during bulk upserts).

Common Qdrant Failure Modes and What Vigilmon Catches

| Scenario | Vigilmon monitor | |---|---| | Qdrant process OOM | /healthz connection refused; alert in < 60 s | | Collection goes red (segment corruption) | Collection status keyword green absent | | Shard replica falls behind | Shard cluster monitor fires; replication lag | | Disk full stops optimizer | optimizer_status not ok; indexing stalls | | Slow HNSW index build | Telemetry latency sentinel fires | | Network partition drops peer | Shard cluster monitor fires | | SSL certificate expires | SSL monitor alerts at 30-day threshold | | Cold start after restart | Readiness monitor fires until segments reload |

Qdrant failures are often invisible to application-layer logs — your LLM application might silently return empty vectors or fall back to keyword search without surfacing an error. Vigilmon's external checks on the health API, collection status, and replication endpoints give your AI/ML platform the observability it needs to maintain SLAs even as embedding workloads scale.

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