Generated banner for Qdrant Monitoring Debugging
Generated logo for Qdrant Monitoring Debugging

Qdrant Monitoring Debugging

GitHubOfficialFirst committed by anush008Distributed by GitHub

  • Skill
  • Review and audit
  • Cloud and DevOps
  • MIT
  • No issues found

From the author

Diagnoses Qdrant production issues using metrics and observability tools. Use when someone reports 'optimizer stuck', 'indexing too slow', 'memory too high', 'OOM crash', 'queries are slow', 'latency spike', or 'search was fast now it's slow'. Also use when performance degrades without obvious config changes.
— the description by anush008

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to diagnosing common Qdrant production issues, including high latency, memory pressure, and optimizer bottlenecks. It emphasizes using built-in metrics and observability endpoints to distinguish between expected system behavior, such as OS page caching, and actual performance degradation. The guide outlines specific diagnostic steps for analyzing optimizer status, memory consumption, and query performance, while highlighting common pitfalls to avoid during the debugging process.

What it does

  • Provides methods to check optimizer status and identify stuck or slow optimization tasks.
  • Explains how to interpret memory metrics to distinguish between resident memory usage and OS page cache.
  • Offers guidance on using response duration metrics to analyze query latency.
  • Details how to identify missing payload indexes by comparing filtered and unfiltered query performance.
  • Lists common root causes for performance degradation, such as unmerged segments after bulk uploads.
  • Warns against common mistakes like making configuration changes during active optimizations.

When to use it

  • When users report that search queries are slow or experiencing latency spikes.
  • When the system exhibits high memory usage or experiences OOM crashes.
  • When optimization tasks appear to be stuck or running for an unexpectedly long time.
  • When performance degrades suddenly without any recent configuration changes.
  • When investigating indexing performance issues.

Advantages

  • Reduces time spent on trial-and-error by focusing on specific metrics.
  • Helps prevent unnecessary configuration changes that could worsen performance.
  • Clarifies the difference between normal system behavior and actual resource leaks.
  • Provides a clear, step-by-step diagnostic path for complex production environments.

Usage examples

“My Qdrant node is crashing with OOM, how do I check if it is a memory leak?”
The agent will guide you to check RSSAnon metrics versus OS page cache usage and verify if resident memory exceeds 80% of total RAM.
“Why are my search queries suddenly very slow?”
The agent will instruct you to check the optimizer status for active merges, verify segment counts, and analyze response duration metrics.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/github/qdrant-monitoring-debugging/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip qdrant-monitoring-debugging.zip -d .agents/skills

Documentation by anush008

How to Debug Qdrant with Metrics

First check optimizer status. Most production issues trace back to active optimizations competing for resources. If optimizer is clean, check memory, then request metrics.

Optimizer Stuck or Too Slow

Use when: optimizer running for hours, not finishing, or showing errors.

  • Use /collections/{collection_name}/optimizations endpoint (v1.17+) to check status Optimization monitoring

  • Query with optional detail flags: ?with=queued,completed,idle_segments

  • Returns: queued optimizations count, active optimizer type, involved segments, progress tracking

  • Web UI has an Optimizations tab with timeline view and per-task duration metrics Web UI

  • If optimizer_status shows an error in collection info, check logs for disk full or corrupted segments

  • Large merges and HNSW rebuilds legitimately take hours on big datasets. Check progress before assuming it's stuck.

Memory Seems Too High

Use when: memory exceeds expectations, node crashes with OOM, or memory keeps growing.

  • Process memory metrics available via /metrics (RSS, allocated bytes, page faults)

  • Qdrant uses two types of RAM: resident memory (data structures, quantized vectors) and OS page cache (cached disk reads). Page cache filling available RAM is normal. Memory article

  • If resident memory (RSSAnon) exceeds 80% of total RAM, investigate

  • Check /telemetry for per-collection breakdown of point counts and vector configurations

  • Estimate expected memory: num_vectors * dimensions * 4 bytes * 1.5 for vectors, plus payload and index overhead Capacity planning

  • Common causes of unexpected growth: quantized vectors with always_ram=true, too many payload indexes, large max_segment_size during optimization

Queries Are Slow

Use when: queries slower than expected and you need to identify the cause.

  • Track rest_responses_avg_duration_seconds and rest_responses_max_duration_seconds per endpoint

  • Use histogram metric rest_responses_duration_seconds (v1.8+) for percentile analysis in Grafana

  • Equivalent gRPC metrics with grpc_responses_ prefix

  • Check optimizer status first. Active optimizations compete for CPU and I/O, degrading search latency.

  • Check segment count via collection info. Too many unmerged segments after bulk upload causes slower search.

  • Compare filtered vs unfiltered query times. Large gap means missing payload index. Payload index

What NOT to Do

  • Ignore optimizer status when debugging slow queries (most common root cause)

  • Assume memory leak when page cache fills RAM (normal OS behavior)

  • Make config changes while optimizer is running (causes cascading re-optimizations)

  • Blame Qdrant before checking if bulk upload just finished (unmerged segments)

Files

ATTRIBUTION.md

Attribution

This folder is an unmodified copy of the Agent Skill "qdrant-monitoring-debugging", distributed by AutoGineer (https://autogineer.com/agent-skills).

The skill's own files are unmodified copies. AutoGineer is not affiliated with or endorsed by the author or the publisher.

Files added by AutoGineer

  • ATTRIBUTION.md: this file, written by AutoGineer

  • LICENSE: copied from LICENSE

Requirements and compatibility

Written for: GitHub Copilot

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

First committed by
GitHub avatar of anush008anush008
Publisher
GitHub (Official)
Distributed by
GitHub
Source
github/awesome-copilot · skills/qdrant-monitoring/debugging · commit 797337f
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced
Contributors
anush008

AutoGineer is not affiliated with or endorsed by anush008 or GitHub.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download qdrant-monitoring-debugging.zip