queue-aiops
queue-aiops is a governed AI-ops MCP server for Redis and RabbitMQ: 20 read tools (including 4 root-cause analyses), 8 audited writes, and undo — every call logged.
Health overviews —
queue_overview(platform-dispatched),rabbitmq_overview,redis_server_infofor version, rates, memory, clients, alarms.Redis reads — memory stats vs maxmemory/eviction/fragmentation, client list by source, SLOWLOG digest (capped 128), CONFIG GET by glob, keyspace key/expiry counts, SCAN-budgeted big-key sampling (max 10k keys / 200 sized, never
KEYS *).RabbitMQ reads — queues (deepest backlog first), single queue detail (counts, rates, consumers, arguments), connections by peer host, channels by unacked pressure, policies, node memory/disk/fd + watermark alarms.
Four flagship RCAs (transparent heuristics, every finding carries numbers/evidence) —
redis_memory_pressure_rca,redis_latency_rca(slowlog patterns + fork/AOF stalls),rabbitmq_queue_backlog_rca(no consumers, unacked pileup, publish>deliver, watermark alarms),connection_churn_analysis(both platforms, optional history for deltas). Each accepts injectedtelemetry/snapshot/queuesfor pure analysis or pulls live.Medium-risk writes (dry-run previewable) —
redis_config_set(reversible, refuses lockout params like requirepass/bind/port/tls-*),redis_kill_client(irreversible, captures priorState),declare_queue,set_policy,delete_policy.High-risk writes —
purge_queueanddelete_queue(irreversible/high impact; delete undo re-declares queue definition but not its messages).Undo —
undo_list(with measured truncation +effectVerifiedflag) andundo_apply(dispatches the inverse tool, once per token, dry-run supported).Governance built in — every MCP/CLI call lands an audit row in
~/.queue-aiops/audit.db, secret-redacted; call/time budgets and a runaway-loop breaker; risk tiers recorded (labels, not gates); encrypted credentials.
Provides governed RabbitMQ operations: queue-backlog RCA, queue listing/detail/declare/delete/purge, policy management, connection/channel inspection, node health, and connection-churn analysis, with every call audited and reversible writes undoable.
Provides governed Redis operations: memory-pressure RCA, latency RCA, slowlog analysis, client listing and kill, config get/set, big-key sampling, and connection-churn analysis, with every call audited and reversible writes undoable.
Queue AIops
Audit availability: Real writes require a committed
pendingaudit 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 doctoris 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-toolsThe 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: yesRestart 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 targetThen 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 firstRelated 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 | 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 viaQUEUE_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_RATIONALEare optional annotations recorded on the row (who/why), never required and never blocking.Undo — reversible writes capture the real before-state first:
redis_config_setrecords the prior value from CONFIG GET;set_policy/delete_policyrecord the prior policy;delete_queuerecords 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_queueanddelete_queueare 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_PASSWORDfor 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 relocatedQUEUE_AIOPS_HOME, and any optionalQUEUE_AUDIT_APPROVED_BY/QUEUE_AUDIT_RATIONALEaudit annotations) must be set in theenvblock 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|churnVerification 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 toolsconnection_churn_analysisARead-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_queueADestructive
[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_policyADestructive
[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_queueADestructive
[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_channelsARead-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_connectionsARead-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_policiesARead-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_queuesARead-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_healthARead-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_queueADestructive
[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_detailARead-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_overviewARead-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_overviewARead-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_rcaARead-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_keysARead-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_clientsARead-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_getBRead-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_setADestructive
[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_keyspaceBRead-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_clientADestructive
[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_rcaARead-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_rcaARead-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_statsBRead-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_infoARead-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_slowlogARead-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_policyADestructive
[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_applyADestructive
[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_listARead-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
Scored across 28 tools
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.
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.
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.
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
Related MCP Connectors
39 stateless MCP tools (32 APIs): AI guardrails, PII/secrets, MCP lint, SSRF & EU checksums.
Autonomous and governed SRE & MLOps control plane for AI agent platforms.
Google Ads MCP with 20,000+ account peer context and staged approve-then-execute writes.
Control plane for autonomous software labor. Agents claim objectives over MCP with audit trail.
Related MCP Servers
- AlicenseAqualityBmaintenanceGoverned 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.35MIT
- AlicenseAqualityBmaintenanceGoverned 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.39MIT
- AlicenseAqualityBmaintenanceGoverned 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.28MIT
- AlicenseAqualityBmaintenanceGoverned 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.48MIT