Skip to main content
Glama

Queue AIops

Audit availability: Real writes require a committed pending audit row and stop before contacting the platform if storage is unavailable. Reads and previews may continue with a warning; new audit rows store outcome summaries rather than full responses.

Governed AI-ops for redis + rabbitmq. queue-aiops is for the team running their own cache and message broker — a redis that "suddenly eats memory", a rabbitmq whose queues quietly grow until publishers block — without an enterprise observability suite. It gives an AI agent (or a human at the CLI) a governed toolset over both: transparent root-cause analyses for memory pressure, latency, queue backlog, and connection churn, plus the handful of writes an operator actually needs (config set, client kill, purge/delete queue, policies) — every call audited, budgeted, risk-tiered, and undo-recorded by the built-in governance harness.

Disclaimer: Community-maintained open-source project, not affiliated with, endorsed by, or sponsored by the Redis or RabbitMQ projects or their respective owners. Redis and RabbitMQ are trademarks of their respective owners.

Verification: behaviour is covered by a mock-based test suite; not yet validated against live brokers. Both redis and rabbitmq are free/self-hostable (one lab container or package install each), so a lab check is easy — queue-aiops doctor is the fastest live probe, and docs/VERIFICATION.md is the checklist.

Quick start

As a Claude Code plugin

One install gives an agent both the skill and the MCP server:

/plugin marketplace add AIops-tools/marketplace
/plugin install queue-aiops@aiops-tools

The MCP server is fetched with uv and pinned to the package version this plugin declares, so an audit row can be traced back to the code that wrote it. Credentials are still configured with queue-aiops init — see below.

As an OpenClaw plugin

The same bundle is published on ClawHub, where one install delivers the skill and its MCP server together:

openclaw plugins install clawhub:@zw008/queue-aiops
openclaw skills info queue-aiops          # expect: Visible to model: yes

Restart the OpenClaw gateway afterwards so it loads the plugin. The MCP server is fetched with uv, pinned to this exact release, so uvx has to be on PATH — without it the skill still installs but reports Visible to model: no. Credentials are configured exactly as below.

As a CLI or standalone MCP server

uv tool install queue-aiops

queue-aiops init      # wizard: pick platform (redis/rabbitmq), host/port, encrypted secret
queue-aiops doctor    # config + secret + connectivity check (PING / /api/overview)
queue-aiops overview  # one-shot health summary for the default target

Then the interesting parts:

queue-aiops analyze memory     # redis memory-pressure RCA (maxmemory, eviction, frag, big keys)
queue-aiops analyze latency    # redis latency RCA (slowlog digest, fork/AOF stalls)
queue-aiops analyze backlog    # rabbitmq queue-backlog RCA (consumers, unacked, watermarks)
queue-aiops analyze churn      # connection churn, both platforms
queue-aiops redis bigkeys      # SCAN-budgeted big-key sample (never KEYS *)
queue-aiops rabbitmq queues    # deepest backlog first

Related MCP server: observability-aiops

What this tool does, and does not, decide

It delivers broker operations — reads and writes — accurately and efficiently, and records every one of them. It does not decide whether a write is allowed to happen. That is the agent's judgement, or the permission of the account you connect it with: give the Redis connection an ACL user restricted to read commands, or the RabbitMQ management user only the monitoring tag, and the writes fail at the broker — the place that actually owns the permission.

So there is no read-only switch, no policy file, no approval gate to configure. The one thing the tool guarantees is that nothing is silent: every call, over MCP and over the CLI alike, lands an audit row in ~/.queue-aiops/audit.db, and reversible writes still capture their before-state and record an inverse.

Each tool declares a risk_level, kept in agreement with its [READ]/[WRITE] documentation tag by a test, and carried into the audit row as a descriptive tier — so a reviewer can see at a glance that a row was a high-risk delete. It is a label, not a gate.

Running a smaller / local model? See agent-guardrails.md — it lists the guardrails this tool now enforces for you (so you don't spend prompt budget restating them) and gives a ready-made system prompt for what's left.

Support scope

Platform

Protocol

Coverage

redis (5.x–7.x wire protocol via redis Python client)

RESP, password optional, TLS optional

INFO (server/memory/clients/stats/persistence/keyspace), SLOWLOG, CLIENT LIST/KILL, CONFIG GET/SET, MEMORY STATS/USAGE, SCAN-budgeted big-key sampling, DBSIZE, PING

rabbitmq (management plugin HTTP API)

HTTP(S), Basic auth

/api/overview, /api/queues (+ per-vhost, detail, purge, declare, delete), /api/connections, /api/channels, /api/consumers, /api/policies (get/set/delete), /api/nodes

28 MCP tools — 20 reads (incl. 4 flagship RCAs) + 8 governed writes.

Group

Tools

R/W

Overview

queue_overview

read

redis reads

redis_server_info, redis_memory_stats, redis_clients, redis_slowlog, redis_config_get, redis_keyspace, redis_big_keys

read

rabbitmq reads

rabbitmq_overview, list_queues, queue_detail, list_connections, list_channels, list_policies, node_health

read

Flagship RCAs

redis_memory_pressure_rca, redis_latency_rca, rabbitmq_queue_backlog_rca, connection_churn_analysis

read

Writes (medium)

redis_config_set, redis_kill_client, declare_queue, set_policy, delete_policy

write

Writes (high)

purge_queue, delete_queue

write

Undo

undo_list, undo_apply

read / write

The four RCAs are transparent heuristics that report their numbers — thresholds are named constants, every finding carries its evidence, never a black-box verdict. Big-key sampling walks at most 10,000 keys with SCAN and sizes at most 200 with MEMORY USAGE — never KEYS * — and reports its coverage.

Governance

Every MCP tool — and every CLI write, which routes through the same governed functions — runs through the bundled @governed_tool harness (queue_aiops.governance — no external dependency). It records; it does not authorize whether a write may happen (see above):

  • Audit — every call lands in ~/.queue-aiops/audit.db (relocatable via QUEUE_AIOPS_HOME), secret-redacted. The CLI writes the same row the MCP path does — there is no unaudited entry point.

  • Budget / runaway guard — a safety backstop, not an authorization gate: call/time ceilings (QUEUE_MAX_TOOL_CALLS, QUEUE_MAX_TOOL_SECONDS) + a runaway-loop breaker stop a stuck agent from burning unbounded calls/time.

  • Risk tier — a descriptive label on the audit row derived from risk_level; it gates nothing. QUEUE_AUDIT_APPROVED_BY / QUEUE_AUDIT_RATIONALE are optional annotations recorded on the row (who/why), never required and never blocking.

  • Undo — reversible writes capture the real before-state first: redis_config_set records the prior value from CONFIG GET; set_policy/delete_policy record the prior policy; delete_queue records the queue's definition and its undo re-declares it (the messages are not restored — the descriptor says so). Irreversible writes (purge_queue, redis_kill_client) record priorState only.

  • Dry-run + double-confirm — every write takes dry_run=True (MCP) / --dry-run (CLI); CLI writes double-confirm and execute through the same governed twins, so they land in the audit log too. purge_queue and delete_queue are risk=high with dry-run + double confirmation at the CLI.

  • Credentials live encrypted in ~/.queue-aiops/secrets.enc (Fernet + scrypt master password; QUEUE_AIOPS_MASTER_PASSWORD for non-interactive use). Redis passwords are optional — an auth-less lab instance is a supported target.

MCP configuration

{
  "mcpServers": {
    "queue-aiops": {
      "command": "uvx",
      "args": ["--from", "queue-aiops", "queue-aiops-mcp"],
      "env": {
        "QUEUE_AIOPS_MASTER_PASSWORD": "your-master-password"
      }
    }
  }
}

env-block caveat: MCP clients launch the server with a minimal environment — your shell profile is not sourced. Anything the server needs (QUEUE_AIOPS_MASTER_PASSWORD, a relocated QUEUE_AIOPS_HOME, and any optional QUEUE_AUDIT_APPROVED_BY/QUEUE_AUDIT_RATIONALE audit annotations) must be set in the env block above, not just in your terminal.

Or, with the package installed: queue-aiops mcp.

CLI reference (short)

queue-aiops init | doctor | overview | mcp
queue-aiops secret set|list|migrate ...
queue-aiops redis info|memory|clients|slowlog|config-get|keyspace|bigkeys
queue-aiops redis config-set <param> <value> [--dry-run]
queue-aiops redis kill-client --id <id> | --addr <ip:port> [--dry-run]
queue-aiops rabbitmq overview|queues|queue|connections|channels|policies|nodes
queue-aiops rabbitmq purge|delete-queue|declare-queue <name> [--vhost /] [--dry-run]
queue-aiops rabbitmq set-policy|delete-policy <name> ... [--dry-run]
queue-aiops analyze memory|latency|backlog|churn

Verification status

Live-verified against Redis 7.4.9 and RabbitMQ 3.13.7 (2026-07-19/20). Connectivity, every Redis read (cross-checked against redis-cli ground truth), all four analyses, and the full governance loop (real redis_config_set → audit row → undo restoring the prior value) were exercised against a real server. That run found and fixed a real defect: integer quantities — key counts, client counts, byte totals — were rendered as floats (202.0 keys), which equality assertions cannot catch.

The RabbitMQ group is now verified end-to-end too — reads cross-checked against rabbitmqadmin, and set_policy → undo_apply closing on the live broker. Redis cluster/sentinel topologies and AUTH/TLS connections remain unverified.

docs/VERIFICATION.md records exactly what was checked and what is still open. queue-aiops doctor is the fastest live check.

Contributing

缺功能提 issue/PR 欢迎留言 — missing a read you need (streams/consumer groups, quorum-queue specifics, shovel/federation status), another broker platform, or a threshold that doesn't fit your fleet? Open an issue or PR at github.com/AIops-tools/Queue-AIops — platform registry entries are additive and small.

License

MIT

Available Tools

28 tools
connection_churn_analysisA
Read-only

[READ] Connection/channel churn → cause + action; works on both platforms.

The flagship churn analysis: for a redis target — new-connections rate vs steady clients (reconnect-per-operation smell) and rejected connections (maxclients); for a rabbitmq target — overview churn rates, channels-per- connection ratio (leak smell), and growth vs a prior snapshot. Both group clients by source so a finding can be pinned to an app. Call it once, keep the returned snapshot fields, and pass them back later as 'history' for delta-based churn. Pass 'snapshot' for pure analysis, or a target to pull live.

Args: snapshot: Injected snapshot (from a prior call's live pull shape); skips the live pull. history: A prior snapshot for delta analysis (optional). target: Broker target name from config; omit for the default.

Returns dict: {platform, metrics, bySource, comparedToHistory, thresholds, findings:[{cause, action, evidence}], note}.

Inputs: target, history, snapshot.

declare_queueA
Destructive

[WRITE][risk=medium] Declare (create) a rabbitmq queue; undo deletes it if new.

Records whether the queue already existed; the undo (delete) is recorded only for a newly-created queue. Also the replay target for delete_queue's undo. Pass dry_run=True to preview.

Args: vhost: The queue's vhost (the default vhost is '/'). name: Queue name to declare. durable: Survive broker restarts (default True). auto_delete: Delete when the last consumer disconnects (default False). arguments: Optional x-arguments (e.g. {'x-queue-type': 'quorum'}). dry_run: If True, preview without declaring. target: rabbitmq target name from config; omit for the default.

Inputs: name (required), vhost (required), target, dry_run, +3 more.

delete_policyA
Destructive

[WRITE][risk=medium] Delete a rabbitmq policy; the undo re-creates it.

Reads the policy first so the recorded undo can re-create it exactly. Pass dry_run=True to preview.

Args: vhost: The policy's vhost (the default vhost is '/'). name: Policy name (from list_policies). dry_run: If True, preview without deleting. target: rabbitmq target name from config; omit for the default.

Inputs: name (required), vhost (required), target, dry_run.

delete_queueA
Destructive

[WRITE][risk=high] Delete a rabbitmq queue; the undo re-declares its definition.

Reads the queue first so priorState carries the definition (durable / auto_delete / arguments) and message count; the recorded undo re-declares the queue with those properties — its messages are NOT restored. Pass dry_run=True to preview.

Args: vhost: The queue's vhost (the default vhost is '/'). name: Queue name (from list_queues). dry_run: If True, preview without deleting. target: rabbitmq target name from config; omit for the default.

Inputs: name (required), vhost (required), target, dry_run.

list_channelsA
Read-only

[READ] Channels with unacked/prefetch pressure, most unacked first.

Args: target: rabbitmq target name from config; omit for the default.

Returns an envelope: {"channels": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — do not treat this as the complete set.

Inputs: target.

list_connectionsA
Read-only

[READ] Client connections grouped by peer host, busiest first.

Args: target: rabbitmq target name from config; omit for the default.

Returns an envelope: {"connections": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — do not treat this as the complete set.

Inputs: target.

list_policiesA
Read-only

[READ] Policies (optionally one vhost) with pattern, priority, definition.

Args: vhost: Restrict to one vhost (the default vhost is '/'); omit for all. target: rabbitmq target name from config; omit for the default.

Returns an envelope: {"policies": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — do not treat this as the complete set.

Inputs: vhost, target.

list_queuesA
Read-only

[READ] Queues (optionally one vhost), deepest backlog first.

Args: vhost: Restrict to one vhost (the default vhost is '/'); omit for all. target: rabbitmq target name from config; omit for the default.

Returns an envelope: {"queues": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — do not treat this as the complete set.

Inputs: vhost, target.

node_healthA
Read-only

[READ] Node memory/disk/fd posture + watermark alarms, most loaded first.

Args: target: rabbitmq target name from config; omit for the default.

Inputs: target.

purge_queueA
Destructive

[WRITE][risk=high] Purge all ready messages from a rabbitmq queue. IRREVERSIBLE.

Reads the queue first so priorState carries the message count about to be destroyed (audit evidence); unacked messages are not purged. No undo — purged messages cannot be restored. Pass dry_run=True to preview.

Args: vhost: The queue's vhost (the default vhost is '/'). name: Queue name (from list_queues). dry_run: If True, preview without purging. target: rabbitmq target name from config; omit for the default.

Inputs: name (required), vhost (required), target, dry_run.

queue_detailA
Read-only

[READ] One queue's full detail: counts, rates, consumers, memory, arguments.

Args: vhost: The queue's vhost (the default vhost is '/'). name: Queue name (from list_queues). target: rabbitmq target name from config; omit for the default.

Inputs: name (required), vhost (required), target.

queue_overviewA
Read-only

[READ] One-shot summary: platform + version + backlog/memory/client health.

Platform-dispatched: a redis target reports memory posture, clients, ops/sec and hit rate; a rabbitmq target reports queue/message totals, connection/channel counts, rates, and node alarms.

Args: target: Broker target name from config; omit for the default.

Inputs: target.

rabbitmq_overviewA
Read-only

[READ] Broker identity + totals: version, queue/message counts, rates, churn.

Args: target: rabbitmq target name from config; omit for the default.

Inputs: target.

rabbitmq_queue_backlog_rcaA
Read-only

[READ] Rank backlogged queues and map each to a cause + action.

The flagship backlog RCA: flags queues over the backlog threshold and classifies each — no consumers attached, unacked pileup (consumers not acking), publish rate outpacing delivery, or residual backlog — plus global memory/disk watermark alarms that block every publisher via flow control. Every finding carries its numbers. Pass 'queues' (and optionally 'nodes') for pure analysis, or a target to pull live.

Args: vhost: Restrict the live pull to one vhost; omit for all. top: How many queue rows to return, deepest first (default 20). queues: Injected rows {name, vhost, messages, messagesReady, messagesUnacked, consumers, publishRate, deliverRate, state}. nodes: Injected node_health rows {name, memAlarm, diskAlarm, ...}. target: rabbitmq target name from config; omit for the default.

Returns dict: {queuesEvaluated, backloggedCount, globalFindings, queues:[{name, vhost, messages, consumers, cause, action, ...}], thresholds, note}.

Inputs: top, nodes, vhost, queues, +1 more.

redis_big_keysA
Read-only

[READ] SCAN-budgeted big-key sample — largest sampled keys first.

Walks at most 10,000 keys with SCAN and sizes at most 200 of them with MEMORY USAGE (never KEYS *), so it is safe on a production instance; coveragePct reports how partial the sample is.

Args: top: How many key rows to return, largest first (default 20). target: redis target name from config; omit for the default.

Returns an envelope: {"topKeys": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — do not treat this as the complete set.

Inputs: top, target.

redis_clientsA
Read-only

[READ] Connected redis clients grouped by source address, busiest first.

Args: target: redis target name from config; omit for the default.

Returns an envelope: {"clients": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — do not treat this as the complete set.

Inputs: target.

redis_config_getB
Read-only

[READ] CONFIG GET for a glob pattern (e.g. 'maxmemory*').

Args: pattern: Config-name glob (default '*'). target: redis target name from config; omit for the default.

Inputs: target, pattern.

redis_config_setA
Destructive

[WRITE][risk=medium] Set one redis config parameter; reversible.

Reads the parameter first (CONFIG GET) so the harness records an undo that restores its prior value. Runtime-only — not persisted to the config file. Pass dry_run=True to preview.

Refuses the parameters that would lock this tool out of the instance (requirepass, masterauth, bind, port, protected-mode, maxclients, unixsocket, aclfile, tls-*) — the undo could never be replayed over a connection those settings break. Change those in redis.conf and restart. The refusal applies under dry_run too: a preview whose real call would be refused must report that, not a green 'wouldSet'.

Args: parameter: Config parameter name (e.g. maxmemory-policy), from redis_config_get. value: New value. dry_run: If True, preview without changing. target: redis target name from config; omit for the default.

Inputs: value (required), parameter (required), target, dry_run.

redis_keyspaceB
Read-only

[READ] Per-db key counts and expiry coverage from INFO keyspace.

Args: target: redis target name from config; omit for the default.

Inputs: target.

redis_kill_clientA
Destructive

[WRITE][risk=medium] Disconnect one redis client by id or addr. IRREVERSIBLE.

Captures the client's CLIENT LIST row as priorState (who/where/last command) before the kill — the connection cannot be restored, so no undo is recorded; most clients transparently reconnect. Pass dry_run=True to preview.

Refuses this tool's own connection, by id or by addr — including under dry_run, which must report a refusal rather than preview a call that will be refused.

Args: client_id: Client id from redis_clients (preferred). addr: Or the client's 'ip:port' address. dry_run: If True, preview without disconnecting. target: redis target name from config; omit for the default.

Inputs: addr, target, dry_run, client_id.

redis_latency_rcaA
Read-only

[READ] Diagnose redis latency → slowlog digest + stall causes + actions.

The flagship latency RCA: digests the SLOWLOG by command pattern (flagging O(N)/blocking commands), and reads stall signals from INFO — blocked clients, fork stalls (BGSAVE/AOF rewrite), delayed AOF fsyncs (slow disk), and dataset loading. Every finding carries its numbers. Pass 'telemetry' for pure analysis, or a target to pull live.

Args: slow_us: Slowlog duration (microseconds) at/above which a pattern is flagged (default 10000 = 10ms). telemetry: Injected {slowlog:[{command, durationUs}], blockedClients, latestForkUsec, aofDelayedFsync, aofRewriteInProgress, rdbBgsaveInProgress, loading}; skips the live pull. target: redis target name from config; omit for the default.

Returns dict: {slowlogPatterns, patternsOverThreshold, thresholds, findings:[{cause, action, evidence}], note}.

Inputs: target, slow_us, telemetry.

redis_memory_pressure_rcaA
Read-only

[READ] Diagnose redis memory pressure → cause + action, with numbers.

The flagship memory RCA: used vs maxmemory (+ eviction policy — noeviction near the limit means writes will OOM), evicted-keys pressure, fragmentation ratio (high = defrag, below 1 = likely swapping), and the SCAN-budgeted big-key sample. Every finding carries its numbers, not a black-box verdict. Pass 'telemetry' for pure analysis, or a target to pull live.

Args: used_pct: used/maxmemory %% at/above which pressure is flagged (default 85). telemetry: Injected {memory:{...memory_stats fields}, evictedKeys, bigKeys:{topKeys:[...]}}; skips the live pull. target: redis target name from config; omit for the default.

Returns dict: {pressure, usedPctOfMax, maxmemoryPolicy, fragmentationRatio, evictedKeys, thresholds, findings:[{cause, action, evidence}], note}.

Inputs: target, used_pct, telemetry.

redis_memory_statsB
Read-only

[READ] redis memory posture: used vs maxmemory, eviction policy, fragmentation, peaks.

Args: target: redis target name from config; omit for the default.

Inputs: target.

redis_server_infoA
Read-only

[READ] redis server identity + health basics: version, role, clients, ops/sec, hit rate.

Args: target: redis target name from config; omit for the default.

Inputs: target.

redis_slowlogA
Read-only

[READ] Recent SLOWLOG entries, slowest first.

Args: count: Max entries to pull (capped at 128). target: redis target name from config; omit for the default.

Returns an envelope: {"entries": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — do not treat this as the complete set.

Inputs: count, target.

set_policyA
Destructive

[WRITE][risk=medium] Create/update a rabbitmq policy; reversible.

Reads the policy first: the recorded undo restores the prior policy fields, or deletes the policy when it is newly created. Pass dry_run=True to preview.

Args: vhost: The policy's vhost (the default vhost is '/'). name: Policy name. pattern: Regex the policy matches queue/exchange names against. definition: Policy definition object (e.g. {'max-length': 100000}). priority: Policy priority (higher wins; default 0). apply_to: 'queues', 'exchanges', or 'all' (default). dry_run: If True, preview without changing. target: rabbitmq target name from config; omit for the default.

Inputs: name (required), vhost (required), pattern (required), definition (required), +4 more.

undo_applyA
Destructive

[WRITE][risk=medium] Apply a recorded undo by dispatching its inverse tool.

The inverse runs through its own governed tool, so it is audited under its own risk tier. Pass dry_run=True to preview the inverse call without executing it. A token can only be applied once.

Args: undo_id: The undoId from undo_list (or an _undo_id in a write result). dry_run: If True, preview the inverse tool + params without running it. target: Passed through to the inverse tool when it accepts a target.

Inputs: undo_id (required), target, dry_run.

undo_listA
Read-only

[READ] List recorded, not-yet-applied undo tokens (most recent first).

Each entry names the original tool, the inverse tool that undo_apply would run, and a human note. Use the undoId with undo_apply.

Returns {"undos": [...], "returned": N, "limit": L, "truncated": bool}. truncated is measured (one extra row is fetched), not guessed from a length coincidence: when it is true there are MORE tokens than shown, so re-run with a higher limit rather than reporting the list as complete.

Each entry carries effectVerified. False means the original write lost its response, so the change it reverses is PROBABLE, not confirmed — check the live state before applying, and do not report the result as a restore of a state that may never have been reached.

Args: limit: Max rows to return (default 50, capped at 500). target: Unused (undo state is host-local); accepted for CLI uniformity.

Inputs: limit, target.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 28 tools

    Disambiguation4/5

    Most tools have clearly distinct purposes: raw metrics vs. RCA diagnostics vs. CRUD actions. The main overlap is among overview-style tools (queue_overview, rabbitmq_overview, redis_server_info), which could cause misselection, but descriptions generally clarify their different scopes.

    Naming Consistency3/5

    All names use snake_case and are readable, but conventions are mixed. Action tools use verb_noun (list_queues, delete_queue), redis reads use a redis_ prefix plus noun (redis_slowlog, redis_memory_stats), and overviews vary between queue_overview and rabbitmq_overview.

    Tool Count2/5

    28 tools exceeds the 25+ heavy threshold. While two platforms (Redis and RabbitMQ) plus undo add scope, the surface includes overlapping raw-vs-RCA and overview tools that could be consolidated, making the set feel inflated.

    Completeness4/5

    The surface covers core diagnostics, queue/policy CRUD, config changes, client kill, and undo management for both Redis and RabbitMQ. Gaps remain for RabbitMQ exchanges/bindings and user/vhost administration, but agents can work around most AIOps workflows.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      Governed MySQL + MariaDB DBA operations — slow-query, lock-wait/deadlock, replication, and fragmentation RCA, with unbypassable audit logging (MCP + CLI), budget/runaway guards, dry-run, and undo/rollback.
      35
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Governed Prometheus + Grafana operations — firing-alert and scrape-target RCA, alert noise/flapping analysis, silences, and dashboards, with unbypassable audit logging (MCP + CLI), budget/runaway guards, dry-run, and undo/rollback.
      39
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Governed CI/CD operations for self-hosted GitLab and Gitea — pipeline-failure, runner, artifact-bloat, and stale-branch RCA, with unbypassable audit logging (MCP + CLI), budget/runaway guards, dry-run, and undo/rollback.
      28
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Governed MinIO object-storage operations — capacity, exposure-surface audit, lifecycle, and healing RCA, with guarded bucket writes, unbypassable audit logging (MCP + CLI), budget/runaway guards, dry-run, and undo/rollback.
      48
      MIT