proxy-aiops
Governed, audited proxy operations for Traefik, Caddy, and HAProxy via MCP/CLI.
Read overview, version, entrypoints/listeners, routes, services, upstream health, middlewares, TLS certificates, traffic stats, error counters, and config snapshots/searches.
Run flagship RCA analyses:
backend_health_rca,cert_expiry_sweep,error_rate_rca, androute_conflict_analysis.Perform governed, reversible Caddy config writes (
set_config_value,delete_config_path,load_config) and HAProxy runtime writes (set_server_state,set_server_weight), with dry-run previews.Record undo descriptors for reversible writes, then list/apply them with
undo_listandundo_apply.Audit every MCP/CLI call, enforce budget/runaway guards, label risk tiers, and sanitize proxy-returned output.
Return teaching errors for unsupported platform/capability combinations instead of silent no-ops.
Provides integration with Caddy's admin API, enabling AI agents to read and manage the live Caddy configuration, including routes, services, certificates, and config tree operations (get/set/delete/load) with reversible undo and audit logging.
Proxy 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, audited AI-ops for Traefik, Caddy and HAProxy reverse proxies / load balancers — for AI agents (via MCP) and humans (via CLI).
Disclaimer: Community-maintained open-source project. Not affiliated with, endorsed by, or sponsored by Traefik Labs, the Caddy project, HAProxy Technologies, or the HAProxy project. Traefik, Caddy and HAProxy are trademarks of their respective owners. MIT licensed.
proxy-aiops speaks to three proxy platforms behind one MCP server — Traefik
(its API under /api/..., metrics-text counters via /metrics), Caddy (the
admin API, default localhost:2019) and HAProxy (the Data Plane API v2 under
/v2/..., HTTP Basic auth) — with the same tools working on all three. Each
target in the config names its own platform; a name-keyed platform registry
selects the API shape (auth + resource paths), and an explicit support matrix
raises teaching errors for ops a platform genuinely cannot do — e.g. Traefik
writes point you at its providers (file, container labels, orchestrator CRDs), never
a silent no-op.
Every tool runs through a built-in governance harness (vendored, zero external dependency): audit log, token/call budget with runaway circuit-breaker, descriptive risk-tier labelling, undo-token recording, and output sanitisation.
Why this exists
One server, three proxies — Traefik, Caddy and HAProxy in a mixed edge, spoken to through identical tool names. Adding another proxy later is a new platform descriptor, not a rewrite.
Read the whole edge — version, entrypoints/listeners, routes (routers / caddy routes / frontends) with parsed hosts+paths, services and server-level upstream health, middlewares, TLS domain inventory, traffic/error counters, and the live config tree (snapshot + search).
Flagship RCA analyses — transparent heuristics that show their numbers, never a black-box verdict:
backend_health_rca(down upstreams → cause class L4/L6/L7/DNS/maint + action),cert_expiry_sweep(days-to-expiry buckets + per-platform renewal hints),error_rate_rca(5xx share vs the fleet baseline, dominant code → 502/503/504/500 cause), androute_conflict_analysis(shadowed routes, dead routes, redirect loops).Governed writes — caddy config
set/delete/ fullload(the prior subtree/config is fetched first, so the recorded undo replays a real restore) and haproxy runtime serverstate(ready/drain/maint) andweight(undo restores the prior value) — all withdry_runpreviews; delete/load are risk=high with double confirmation at the CLI.
Related MCP server: observability-aiops
What this tool does, and does not, decide
It delivers proxy 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 HAProxy Data Plane API a read-only role, or scope down the Traefik/Caddy admin API you point it at, and the writes fail at the server — 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 ~/.proxy-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.
Tool inventory (28 tools)
Domain | Tools | # | Kind |
Status |
| 3 | read |
Routes |
| 3 | read |
Services |
| 5 | read |
Certificates |
| 1 | read |
Traffic |
| 2 | read |
Config |
| 3 | read |
Flagship analyses |
| 4 | read |
Writes (caddy) |
| 1 | write (med) |
Writes (caddy) |
| 2 | write (high) |
Writes (haproxy) |
| 2 | write (med) |
Undo |
| 2 | read / write |
Reversible writes record an inverse undo descriptor built from the real fetched
before-state (set_config_value restores the prior subtree; delete_config_path
re-creates it; load_config re-loads the snapshotted config; server state/weight
restore the prior value). The undo params match each tool's own signature, so the
descriptor replays as-is.
Per-platform support matrix
Capability | traefik | caddy | haproxy |
Routes / services / upstream health | ✅ | ✅ | ✅ |
Middlewares list | ✅ | teaching note (inline handlers) | teaching note (haproxy.cfg) |
TLS cert inventory + expiry sweep | ✅ | ✅ | teaching note (.pem files) |
Error counters / error-rate RCA | ✅ (/metrics) | teaching note (no per-route counters) | ✅ (stats) |
Config snapshot / search | ✅ (rawdata, read-only) | ✅ | teaching note |
Config writes | teaching error → edit the provider | ✅ (the write surface) | teaching error → runtime writes |
Runtime server state / weight | teaching error → provider | teaching error → config tree | ✅ |
Unsupported combinations raise a teaching error that says what to use instead — never a silent empty result.
Install
uv tool install proxy-aiops # or: pipx install proxy-aiopsQuick 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 proxy-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 proxy-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/proxy-aiops
openclaw skills info proxy-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
proxy-aiops init # wizard: pick platform (traefik/caddy/haproxy) + optional encrypted secret
proxy-aiops doctor # verify config, secrets, and connectivity
proxy-aiops overview # one-shot: version + route/service counts + upstream health
proxy-aiops routes list # normalised route table
proxy-aiops services upstreams # server-level upstream health
proxy-aiops analyze health # backend/upstream health RCA
proxy-aiops analyze errors # 5xx error-rate RCA
proxy-aiops analyze conflicts # shadowed/dead routes, redirect loops
proxy-aiops certs --sweep # TLS cert expiry sweep (traefik/caddy)
proxy-aiops server state app web1 drain --dry-run # governed haproxy write preview
proxy-aiops config set apps/http/servers/srv0 '{"listen":[":8080"]}' --dry-runRun the MCP server (stdio) for an agent:
proxy-aiops mcp # or: proxy-aiops-mcpMCP client config
{
"mcpServers": {
"proxy-aiops": {
"command": "uvx",
"args": ["--from", "proxy-aiops", "proxy-aiops-mcp"],
"env": { "PROXY_AIOPS_MASTER_PASSWORD": "your-master-password" }
}
}
}Env-block caveat: the
envblock is only needed when a credential is stored (haproxy always; traefik/caddy only behind Basic auth). MCP clients do not inherit your shell profile — setPROXY_AIOPS_MASTER_PASSWORD(andPROXY_AIOPS_CONFIG/PROXY_AIOPS_HOMEif you relocated them) explicitly in the client config, or the server cannot unlocksecrets.enc.
Configuration
~/.proxy-aiops/config.yaml (non-secret connection details only):
targets:
- name: edge1
platform: traefik # traefik | caddy | haproxy
base_url: http://192.0.2.10:8080
verify_ssl: true
- name: caddy1
platform: caddy
base_url: http://127.0.0.1:2019
- name: lb1
platform: haproxy
base_url: http://192.0.2.20:5555
username: dpapi # Data Plane API userThe secret — the HAProxy Data Plane API password, or an optional Basic-auth
password in front of Traefik/Caddy — is stored encrypted in
~/.proxy-aiops/secrets.enc (Fernet + scrypt-derived key), never plaintext on
disk. Traefik and Caddy commonly run unauthenticated on localhost, so their
secret is optional (like a local socket); HAProxy's is required. Set it with
proxy-aiops secret set <target> or the init wizard. The store is unlocked by
a master password from PROXY_AIOPS_MASTER_PASSWORD (non-interactive/MCP/CI) or
an interactive prompt (CLI on a TTY). A legacy plaintext env var
PROXY_<TARGET>_SECRET is honoured as a fallback (migrate with
proxy-aiops secret migrate).
Governance
Every MCP tool — and every CLI write, which routes through the same governed
functions — passes through @governed_tool. It records; it does not authorize
(see above).
Audit — every call is logged to
~/.proxy-aiops/audit.db(tool, params with secrets redacted, status, duration, risk tier, and any operator-supplied approver/rationale). 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: per-process token/call caps and a repeat-call circuit breaker stop a stuck agent from burning unbounded calls/time (
PROXY_MAX_TOOL_CALLS,PROXY_RUNAWAY_MAX, …; disable the breaker withPROXY_RUNAWAY_MAX=0).Undo recording — reversible writes record an inverse descriptor to
~/.proxy-aiops/undo.dbfrom the fetched before-state (recording only; an external orchestrator executes it). Undo params match the target tool's own signature, so the descriptor replays as-is.Risk tier — a descriptive label on the audit row derived from
risk_level; it gates nothing.Sanitisation — all proxy-returned text is bounded + control-character sanitised before it reaches the agent.
Platform support & verification status
Platforms: Traefik (API + /metrics), Caddy (admin API), HAProxy (Data Plane API v2).
Test coverage: behaviour is validated against mocked JSON/metrics responses — every module imports, every MCP tool carries the governance marker, the four flagship analyses are unit-tested against synthetic telemetry, the support matrix is asserted to raise teaching errors (never a silent no-op), and reversible writes are asserted to record the correct inverse undo descriptor. The concrete REST paths are modelled from each project's public API and have not yet been exercised against a live proxy. See docs/VERIFICATION.md for the checklist a live run must satisfy. All three platforms are free and self-hostable (a small container-compose lab with traefik + caddy + haproxy/dataplaneapi is a one-evening setup), and
proxy-aiops doctor— a health/info probe per platform — is the fastest live check.Routing note: this tool operates reverse proxies / load balancers. Do NOT use it for firewall rules — use firewall-aiops.
Missing a capability? Open an issue or PR at github.com/AIops-tools/Proxy-AIops — contributions and feedback welcome.
License
MIT — see LICENSE.
Available Tools
28 toolsbackend_health_rcaARead-only
[READ] Down upstreams grouped per service, each mapped to cause + action.
The flagship availability RCA: pulls server-level upstream health, groups per service, and classifies each outage/degradation (connection refused, L4/L7 health-check failure class, DNS, admin maint/drain, all-servers-down) with a recommended action. Every finding carries its numbers. Pass 'upstreams' for pure analysis, or a target to pull live.
Args: service: Optional service/backend filter when pulling live. upstreams: Injected rows {service, server, address, status, checkInfo}; skips the live pull. target: Proxy target name from config; omit for the default.
Returns dict: {servicesEvaluated, outages, degraded, findings:[{service, serversTotal, up, down, maint, failingServers, cause, action}], note}.
Inputs: target, service, upstreams.
cert_expiry_sweepARead-only
[READ] TLS cert inventory bucketed by days-to-expiry + renewal hints.
The flagship cert sweep for traefik/caddy targets: collects the TLS domain inventory, live-probes each domain's served leaf cert (bounded handshake), and buckets by expiry: expired / critical / warning / ok — with a platform-specific renewal hint (ACME resolver / storage checks). Pass 'certs' for pure analysis over {domain, daysToExpiry} rows. haproxy targets return the support matrix's teaching note.
Args: warn_days: Days-to-expiry at/below which a cert is a warning (default 30). critical_days: Days at/below which a cert is critical (default 7). port: TLS port to probe (default 443). certs: Injected rows {domain, daysToExpiry, notAfter?}; skips pull+probe. target: Proxy target name from config; omit for the default.
Returns dict: {certsEvaluated, expired, critical, warning, ok, unknown, certificates (soonest first), thresholds, renewalHint, note}.
Inputs: port, certs, target, warn_days, +1 more.
config_snapshotARead-only
[READ] The live config tree (caddy /config/) or merged dynamic state (traefik /api/rawdata), sanitised and bounded. haproxy returns the support matrix's teaching note.
Args: target: Proxy target name from config; omit for the default.
Inputs: target.
delete_config_pathADestructive
[WRITE][risk=high] Delete a caddy config subtree; reversible — the subtree is captured first and the undo re-creates it.
Pass dry_run=True to preview.
Refuses the 'admin' subtree and the config root: both remove the admin API this tool speaks to, leaving the undo with no way to reach the server. The refusal applies under dry_run too, which must report it rather than preview a call that will be refused.
Args: path: Slash-separated config path to delete. dry_run: If True, preview without deleting. target: Proxy target name from config; omit for the default.
Inputs: path (required), target, dry_run.
error_countersARead-only
[READ] Per-service request/status-code counters (feeds error_rate_rca).
traefik: parsed from the /metrics text endpoint (per-code); haproxy: Data Plane stats (per-class hrsp_*); caddy: teaching note (no per-route counters).
Args: target: Proxy target name from config; omit for the default.
Returns an envelope: {"services": [...], "returned": N, "limit": L, "truncated": bool, "total": T}. When "truncated" is true this proxy serves more services than were returned (only the busiest services are returned).
Inputs: target.
error_rate_rcaARead-only
[READ] Rank services by 5xx share vs the fleet baseline, cause + action.
The flagship error RCA: reads per-service status-code counters (traefik /metrics, haproxy stats), flags services whose 5xx rate crosses the threshold with enough traffic, and maps the dominant code to a cause (503 no-upstream / 502 conn-fail / 504 timeout / 500 app error). Every entry carries its numbers and its multiple vs the fleet baseline. Pass 'counters' for pure analysis. caddy targets return the support matrix's teaching note (no per-route counters).
Args: error_rate_pct: 5xx %% at/above which a service is flagged (default 5.0). min_requests: Minimum requests before a service can be flagged (default 30). counters: Injected rows {service, total, codes:{...}} and/or classes:{"5xx": n}; skips the live pull. target: Proxy target name from config; omit for the default.
Returns dict: {servicesEvaluated, flaggedCount, fleetErrorRatePct, thresholds, flagged:[{service, requestsTotal, errors5xx, errorRatePct, dominantCode, vsBaselineX, severity, cause, action}], note}.
Inputs: target, counters, min_requests, error_rate_pct.
find_routeARead-only
[READ] Which routes would serve a host/path (static match, best first).
Args: host: Hostname to match (e.g. app.example.com). path: Request path to match (default /). target: Proxy target name from config; omit for the default.
Inputs: host (required), path, target.
get_config_valueARead-only
[READ] One value out of the caddy config tree by config path (e.g. apps/http/servers/srv0/routes/0). Off-caddy platforms return the support matrix's teaching note.
Args: path: Slash-separated config path (dot-segments rejected). target: Proxy target name from config; omit for the default.
Inputs: path (required), target.
list_certificatesARead-only
[READ] TLS domain inventory for a traefik/caddy target; optionally handshake-probe each domain for its live expiry.
On haproxy this returns the support matrix's teaching note (certs are .pem files in haproxy.cfg).
Args: probe: If True, TLS-handshake each domain (bounded) to read expiry. port: TLS port to probe (default 443). target: Proxy target name from config; omit for the default.
Inputs: port, probe, target.
list_entrypointsARead-only
[READ] Listeners: traefik entrypoints / caddy server listen addresses / haproxy frontends — where traffic enters this proxy.
Args: target: Proxy target name from config; omit for the default.
Inputs: target.
list_middlewaresARead-only
[READ] Middlewares (traefik). On caddy/haproxy this returns the support matrix's teaching note (their equivalents live inside routes / haproxy.cfg).
Args: target: Proxy target name from config; omit for the default.
Inputs: target.
list_routesBRead-only
[READ] Routes normalised across platforms: {name, hosts, paths, priority, service, tls, enabled, redirectTo}.
Traefik router names and caddy config paths (apps/http/servers/...) come back exactly as the other tools expect them.
Args: host: Optional hostname filter (keeps host-less catch-alls). target: Proxy target name from config; omit for the default.
Inputs: host, target.
list_servicesBRead-only
[READ] Services / backends with per-service server-up counts.
Args: target: Proxy target name from config; omit for the default.
Inputs: target.
list_upstreamsARead-only
[READ] Server-level upstream health rows: {service, server, address, status(up/down/maint/drain), checkInfo, weight}. Feeds backend_health_rca.
Args: service: Optional service/backend filter. target: Proxy target name from config; omit for the default.
Inputs: target, service.
load_configADestructive
[WRITE][risk=high] Replace caddy's FULL running config; reversible — the prior config is snapshotted first and the undo re-loads it.
Pass dry_run=True to preview.
Refuses a config that disables the admin API or moves admin.listen off the configured base_url — the undo re-POSTs the snapshot over that same API. Send the admin block unchanged, or omit it. The refusal applies under dry_run too, which must report it rather than preview a refused call.
Args: config: The full config tree to load (a JSON object). dry_run: If True, preview without loading. target: Proxy target name from config; omit for the default.
Inputs: config (required), target, dry_run.
proxy_overviewARead-only
[READ] One-shot summary: platform/version + route/service counts + upstream up/down health.
Args: target: Proxy target name from config; omit for the default.
Inputs: target.
route_conflict_analysisARead-only
[READ] Shadowed routes, dead routes, and redirect loops (static).
The flagship routing hygiene analysis: fetches the route table and service list and statically finds (1) routes fully covered by an earlier/higher- priority route (they can never match), (2) routes pointing at a missing service or one with zero servers up, and (3) redirect chains that loop. Every finding names the covering route / missing service. Pass 'routes' (and optionally 'services') for pure analysis.
Args: routes: Injected rows {name, hosts, paths, priority, service, enabled, redirectTo}; skips the live pull. services: Injected rows {name, serversTotal, serversUp} for dead-route detection. target: Proxy target name from config; omit for the default.
Returns dict: {routesEvaluated, shadowedCount, deadCount, redirectLoopCount, shadowedRoutes, deadRoutes, redirectLoops, note}.
Inputs: routes, target, services.
route_detailARead-only
[READ] One route's full detail by name (from list_routes).
Args: name: Route name — traefik router name, caddy route config path, or haproxy frontend name. target: Proxy target name from config; omit for the default.
Inputs: name (required), target.
search_configARead-only
[READ] Search the config tree for a string; returns matching config paths (on caddy, directly usable by get/set_config_value).
Args: query: Case-insensitive substring to find in keys and values. target: Proxy target name from config; omit for the default.
Returns an envelope: {"matches": [...], "returned": N, "limit": L, "truncated": bool}. When "truncated" is true there is more than was returned — narrow the query rather than treating these as every match.
Inputs: query (required), target.
service_detailARead-only
[READ] One service/backend's full detail by name (from list_services).
Args: name: Service name — traefik service name, caddy route config path, or haproxy backend name. target: Proxy target name from config; omit for the default.
Inputs: name (required), target.
set_config_valueADestructive
[WRITE][risk=medium] Set a caddy config subtree (e.g. a route's upstreams); reversible — the prior subtree is fetched first and the undo restores it.
Caddy applies the change immediately. On traefik/haproxy this raises the support matrix's teaching error. Pass dry_run=True to preview.
Refuses the 'admin' subtree: that configures the admin API this tool speaks to, so disabling or moving it would end the connection the undo needs. Change the admin block in caddy's own config file and reload locally. The refusal applies under dry_run too — a preview whose real call would be refused must report that, not a green 'wouldSet'.
Args: path: Slash-separated config path (from search_config / list_routes, e.g. apps/http/servers/srv0/routes/0/handle/0/upstreams). value: The JSON value to write at that path. insert: Insert into an array at that index instead of replacing. This is what re-creating a deleted array element requires — Caddy rejects a create at an index past the (now shorter) array. dry_run: If True, preview without changing. target: Proxy target name from config; omit for the default.
Inputs: path (required), value (required), insert, target, +1 more.
set_server_stateADestructive
[WRITE][risk=medium] Set an haproxy server's admin state (ready / drain / maint); reversible — the prior admin state is fetched first and the undo restores it.
drain finishes in-flight sessions but takes no new ones; maint removes the server immediately; ready returns it to rotation. On traefik/caddy this raises the support matrix's teaching error. Pass dry_run=True to preview.
Args: backend: Backend name (from list_services). server: Server name inside the backend (from list_upstreams). state: One of ready, drain, maint. dry_run: If True, preview without changing. target: Proxy target name from config; omit for the default.
Inputs: state (required), server (required), backend (required), target, +1 more.
set_server_weightADestructive
[WRITE][risk=medium] Set an haproxy server's load-balancing weight (0-256); reversible — the prior weight is fetched first and the undo restores it.
Weight 0 stops new traffic to the server without a state change. On traefik/caddy this raises the support matrix's teaching error. Pass dry_run=True to preview.
Args: backend: Backend name (from list_services). server: Server name inside the backend (from list_upstreams). weight: New weight, 0-256. dry_run: If True, preview without changing. target: Proxy target name from config; omit for the default.
Inputs: server (required), weight (required), backend (required), target, +1 more.
traffic_statsARead-only
[READ] Per-service traffic snapshot: requests, latency/rate/sessions where the platform exposes it (traefik /metrics, haproxy stats; caddy returns the support matrix's teaching note).
Args: target: Proxy target name from config; omit for the default.
Returns an envelope: {"services": [...], "returned": N, "limit": L, "truncated": bool, "total": T}. When "truncated" is true this proxy serves more services than were returned.
Inputs: target.
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.
upstream_detailARead-only
[READ] One upstream server's health/state row.
Args: service: Service/backend name. server: Server name or address (from list_upstreams). target: Proxy target name from config; omit for the default.
Inputs: server (required), service (required), target.
version_infoARead-only
[READ] Version / build info (traefik /api/version, haproxy /v2/info; caddy returns a teaching note — its admin API has no version endpoint).
Args: target: Proxy target name from config; omit for the default.
Inputs: 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 target a distinct resource+action, and the raw-list vs RCA-analysis pattern is consistent. However, pairs like list_certificates/cert_expiry_sweep and traffic_stats/error_counters overlap enough that an agent may need to read descriptions to choose.
All names use snake_case and follow recognizable patterns (list_X, X_detail, set_X, *_rca). Some tools are noun phrases rather than verb_noun (config_snapshot, route_conflict_analysis, undo_apply), so the convention is mostly but not perfectly consistent.
28 tools is heavy for one server, and several granular list/detail pairs plus platform-specific wrappers inflate the surface. Each tool maps to a real operation, but consolidation would improve usability, making this borderline rather than well-scoped.
The surface covers broad proxy diagnostics (health, config, certs, routes, errors, traffic) and includes caddy config writes and haproxy server controls with undo. Gaps remain: no log/restart/reload tools, no traefik config writes, and certificate renewal is only hinted at rather than actionable.
Maintenance
Related MCP Connectors
Governed MCP gateway: one endpoint for your tools, with credential custody and audit log.
Zero-secret MCP gateway for AI agents: risk-scored, audited calls with human-in-the-loop approval.
LLM cost optimization gateway, repo token-waste auditor & model arbitrage MCP server.
Fail-closed policy guardrails for AI agents running kubectl, terraform, helm, and argocd.
Related MCP Servers
- AlicenseAqualityDmaintenanceSecurity, cost, and health governance proxy for MCP infrastructure. Enforces YAML-configurable security policies (blocklists, rate limits, token budgets), tracks real token costs via tiktoken, monitors server health with live JSON-RPC probes. Features OAuth 2.1/OIDC with RBAC, web dashboard, payload normalization, semantic shell AST analysis, mTLS, and a formal STRIDE threat model.4134 npm4MIT
- 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 OPNsense + pfSense firewall operations — gateway-health, rule-shadow, and blocked-traffic RCA, with guarded rule/alias writes, unbypassable audit logging (MCP + CLI), budget/runaway guards, dry-run, and undo/rollback.352MIT
- AlicenseAqualityBmaintenanceGoverned SSO/IAM operations for Keycloak and Authentik — login-failure, stale-permission, client-config, and MFA RCA, with unbypassable audit logging (MCP + CLI), budget/runaway guards, dry-run, and undo/rollback.29MIT