MCP App Store
by KeenEthics
Bronto EU icon

Bronto EU MCP Server for ChatGPT

By Bronto

Overview

Investigate Bronto observability data, analyse logs and trends, review monitors, and create saved searches or muted monitors. This listing connects exclusively to Bronto’s EU region and is intended for customers whose Bronto account and data are hosted in Europe.

How to connect

  1. ChatGPT: Open the Bronto EU listing in the ChatGPT app directory and choose Connect. ChatGPT listing Bronto EU exposes 19 tools here.

Tools

create_monitor

ChatGPT
Signals: logs, metrics. Create one or more Bronto monitors. For a SINGLE monitor, pass its fields at the top level (or a full body via monitor). For a BATCH, pass monitors — a list of up to 20 of these same argument objects — and the response is a batch summary {summary:{succeeded,failed,total}, results:[{index, status, id|error, name}]} with failures isolated per item. Every monitor is ALWAYS created MUTED (mute_until=-1) so it can be reviewed before it starts alerting; this cannot be overridden. Supply a full monitor body via monitor (name, queries, threshold, comparison_operator, window) for explicit control. Bronto requires name, comparison_operator, threshold, window and queries — creation is rejected up front if any are missing. no_data_status sets what the monitor reports when a window has no matching events (default OK; use ALERT to fire when a log stops arriving). Each entry in queries must include its own name (in addition to select/from/where); a query without a name is rejected by the backend. When asked to recommend or create monitors, consider multiple signal classes before choosing what to create: availability, error rate, performance, traffic volume, data freshness, and unusually concentrated failures. Prefer specific monitors that isolate a dataset, provider, service, route, region, or other meaningful dimension over one broad aggregate that can hide localized problems. Use get_keys and lightweight aggregate queries to confirm which signal classes are actually supported by the dataset before creating monitors. Avoid stopping at a single obvious failure class if the schema exposes other operational signals. If a signal appears useful but cannot be safely queried because of missing fields, ambiguous units, or string-typed numeric values, report it as a normalization or follow-up gap rather than fabricating a monitor. Use monitor_type to pick the kind of monitor: PATTERN (default, threshold on a query), USAGE (volume/usage alert — give a query whose select is an aggregate such as SUM(bytes_total) and the backend derives the metric automatically; no metric_id needed), CHANGE_DETECTION, or ANOMALY_DETECTION (alerts when one logs query, with no formulas, leaves its normal range: threshold is in baseline spread units, scaled MADs comparable to standard deviations, default 3; comparison_operator ABOVE, BELOW or OUTSIDE for either side, default OUTSIDE; evaluation_window is the baseline period, chosen from window when omitted; seasonality=true adjusts the baseline for the usual daily and weekly cycle, so suits metrics with a regular cycle where a fixed threshold would be noisy). Try the same settings with detect_anomalies first to see how often it would fire. A query targets logs with from log ids, or with collection + dataset/datasets (the tool builds and validates the dataset from_expr), OR a metric (from_expr: "metric_name IN ('kafka.request.queue')"). select can be a plain aggregate over logs (COUNT()) or over a metric's value — AVERAGE(value), SUM(value), MIN(value), MAX(value), and percentiles like P95(value)/P99(value). Add `groups`: ["key"] to alert PER GROUP (e.g. groups:["$service.name"] fires separately for each service) rather than on a single aggregate. Metric-based queries are validated for existence against the metric catalogue before creation (skip_validation=true to override). In a query's `where`, single-quote string VALUES and double-quote field/ATTRIBUTE names that are not simple identifiers — notably $-prefixed attributes: write "$severity_text" = 'ERROR', not $severity_text = 'ERROR' (the unquoted form builds a wrong filter and is rejected). To combine queries (e.g. an error-rate ratio), give each query a distinct `name` and add `formulas`: a list of {name, expression} where the expression references the queries by name, e.g. queries named `errors` and `total` with a formula {name: "error_rate", expression: "errors / total 100"} — the field is expression (not formula) and name is required. Notifications are not caller-supplied: a single EMAIL action to …

detect_anomalies

ChatGPT
Signals: logs. Find anomalies in a metric derived from logs (metric/time-series anomalies only, not log patterns). Returns episodes — runs of consecutive unusual windows — with when, direction, severity, peak value, expected value and band, per group. Each window is scored against a rolling baseline of the preceding windows. Use after timeseries shows something odd, or to answer 'when did this go wrong'. With seasonality 'compare' each episode says whether the usual daily/weekly pattern explains it (explained_by_seasonality); seasonality only applies once a seasonal profile has been trained, otherwise the response reports PROFILE_GENERATING and scores without it. One metric per call. Counts towards search usage limits.

export_resource

ChatGPT
Signals: none. Export a Bronto resource as infrastructure-as-code text, ready to paste into an existing Terraform project. Use when: the user wants to add an existing dashboard, monitor, user, group, SSO identity provider, or Slack/webhook/provider integration to an IaC project and already has, or can resolve, its resource_id. Don't use for: resources without a resource_id yet - resolve a monitor's first with search_monitors, and ask the user for any other resource's id; widgets and metric definitions have no export of their own, only as dependencies inlined into a dashboard or monitor export. Returns: the raw export body as plain text (Terraform/OpenTofu HCL), not JSON-wrapped. Notes: "terraform" and "opentofu" currently produce identical HCL output for every resource_type; pick whichever matches the user's toolchain.

get_all_datasets_keys

ChatGPT
Signals: logs. Retrieve the most frequently occurring keys across all accessible datasets, keyed by log_id, each dataset's keys grouped under the parser-recorded data type ({"STRING": [name, ...], "NUMBER": [...]}). Schemas differ across datasets, so resolve fields per dataset.

get_coverage

ChatGPT
Signals: logs. Report how well each dataset is covered across three axes: monitored (watched by a monitor), searched (queried by anyone), and ingesting (still receiving data). Read-only. The one call that answers "what is watched, used, and alive — and what is a blind spot?" Always returns a datasets list. Each item carries: monitors (the ids of monitors covering it; [] means unmonitored), search {active, bytes}, and ingestion {active, bytes, last_heartbeat_at}. A dataset that ingests but has monitors:[] and search inactive is a live blind spot. The search/ingestion axes come from the usage API; if you lack billing access they degrade to an unavailable note (a top-level usage_unavailable is also set) rather than failing the call. METRICS are the RAW ingested catalogue (every OTEL metric Bronto receives — e.g. kafka.request.queue), NOT the definition list, so metrics that have no monitor/definition still appear (as unmonitored). A metric is monitored when a monitor's metric definition selects it by name. Use filter="kafka*" to answer "which kafka metrics are we watching?". DETAIL: • minimal_output=true (default) — each dataset with monitors (bare ids), search and ingestion axes, plus a coverage rollup {total, groups} grouped by collection (or group_by tag). • minimal_output=false — adds per-dataset tags, monitor {id, name} instead of bare ids, and the metrics lists (monitored_metrics, unmonitored_metrics). Coverage is computed from monitors + datasets + usage + the raw metric catalogue. To see which monitors cover a resource, use search_monitors. include restricts to logs or metrics only. ATTRIBUTE KEYS (full detail): pass resolve_keys=true with minimal_output=false to enrich each log and metric with the attribute keys it carries (Resource:service.name, Resource:host.name, ...). Logs use one bulk call for the whole org; metrics have no bulk endpoint, so they cost one call per metric in the lists, limited by max_key_lookups (keys_truncated indicates the limit was reached; set 0 for unlimited). Use key_names to keep only matching keys (case-insensitive substring, e.g. key_names=["service"] surfaces only Resource:service.name).

get_datasets

ChatGPT
Signals: logs. Retrieve the available logs as MCP datasets. Each dataset carries last_heartbeat_at (ms epoch of last ingest, or null) and active — true when it ingested within the recency window (14 days by default). A null heartbeat is treated as dormant (the field was added recently, so absence means at least ~14 days stale). Use active/last_heartbeat_at to pick which logs to scope a search to: a log dormant for longer than your query window can't contain matches, so focus discrete searches on active logs when the window is within the recency window.

get_datasets_by_name

ChatGPT
Signals: logs. Retrieve available datasets and filter them by dataset name and collection name.

get_error_summary

ChatGPT
Signals: logs. Use this first when investigating errors/warnings, especially over a broad time range. A first-pass triage step that narrows down where the errors are before you run a broad search: it returns org-wide error & warning totals plus a per-dataset breakdown, so you learn which datasets are affected, then drill into only those (their log_id is in by_dataset) with search_logs/timeseries instead of scanning everything. Backed by a precomputed status-analytics path: it does NOT consume search quota, so it is safe to run first over wide windows. by_dataset lists ONLY the datasets that actually have errors/warnings (the backend omits clean datasets), each {log_id, name, collection, errors, warnings} sorted by volume — name/collection are resolved from the datasets catalogue (null if the log_id isn't found). Optionally returns a per-bucket series. Returns {errors, warnings, series?, by_dataset?}. Read-only.

get_key_values

ChatGPT
Signals: logs. Retrieve the observed values for one key in one dataset using the top-keys data.

get_keys

ChatGPT
Signals: logs. Retrieve the most frequently occurring keys for a specific dataset, grouped under the parser-recorded data type: {"STRING": [name, ...], "NUMBER": [...], ...}. Use this before constructing field-specific filters unless the exact field came from the user or a saved search. Copy returned names exactly; quote dotted or hyphenated field names in search_filter, e.g. "Nested.Field-Name"='value'. Use the type to build the predicate: NUMBER/boolean comparisons use the bare unquoted literal (field >= 500); STRING values use single quotes ('value'). Aggregates like SUM/AVG/percentiles apply to NUMBER fields only.

get_saved_searches

ChatGPT
Signals: logs. Retrieve saved searches available to the authenticated Bronto user. Provide saved_search_id to fetch one saved search with its query configuration; omit it to list available saved searches. Optional search parameters can filter the list by text query, tags, arbitrary key, or arbitrary value.

get_usage

ChatGPT
Signals: none. Summarise usage of your org's datasets on two activity axes: ingestion (is data still arriving?) and search (is anyone querying it?). Returns a summary — per-axis counts (active/inactive), exact bytes, and the org max limit (a per-calendar-month quota, so compare against bytes over a month-to-date window; reading limits needs permission — if denied the limit is dropped and a top-level limits_unavailable note is set) — plus a datasets list. Each dataset carries log_name, log_id, per-axis bytes, and last_heartbeat_at (last time data arrived); minimal_output=false adds per-axis events/count and period-over-period delta_factor, status (ingest_inactive/search_inactive/active), tags, and parser/modified/system metadata.

search_logs

ChatGPT
Signals: logs. Execute a query that returns matching events from log data. For investigation, prefer a small limit first, then expand only if needed. Bare words in search_filter perform full-text matching across the event. Field predicates such as "field"='value' only match that exact field; call get_keys before using a field name unless the field came from the user or a saved search. For trace ids, request ids, or other opaque-identifier investigations, start with a bare full-text word search unless the user explicitly asks for a field-specific match. When the user does ask for a field-specific match, copy the exact field spelling from get_keys and quote dotted or hyphenated field names, for example "Nested.Field-Name"='req-8f3a1c2d'. If that exact-field query returns zero, recheck the field spelling with get_keys before reporting zero.

search_monitors

ChatGPT
Signals: logs, metrics. Search, filter, and inspect Bronto monitors. Without monitor_id, search monitors by a case-insensitive substring query and/or status. With monitor_id, inspect that monitor. By default this returns compact monitor identity/status. Set minimal_output=false to return full monitor objects, embed recent event history, and include the monitor's query definition (the backing queries and formulas) for a direct monitor lookup. Events indicate what triggered the monitor: status transitions (previous_status -> status) with a unix-ms time and message, newest first. For group-by monitors, the per-group detail is carried in each event's group_status_transitions. Bound the events by from_ts/to_ts (unix epoch ms) and limit how many are returned with limit (defaults to 20).

timeseries

ChatGPT
Signals: logs. Execute an aggregate query that returns totals, grouped results, or time-series data from log data. Use this for counts, rates, grouped summaries, and trend analysis before fetching raw events. Bare words in search_filter perform full-text matching across the event. Field predicates only match exact fields; call get_keys before using a field name unless it came from the user or a saved search. For field-specific matches, copy the exact field spelling from get_keys and quote dotted or hyphenated field names, for example "Nested.Field-Name"='req-8f3a1c2d'. If an exact-field aggregate returns zero, recheck the field spelling with get_keys before reporting zero. Response shape: each group in timeseries has a 'count' field (matching event count, not a byte value) and a 'value' field (the numeric aggregate result for your metric, e.g. SUM of bytes). Use 'value' as the answer for byte/numeric metrics; do not report 'count' as a byte total.

validate_monitors

ChatGPT
Signals: logs, metrics. Health-check EXISTING Bronto monitors: confirm each is backed by a working query, and whether it has data. For each monitor, its backing metric definition is resolved and that query (from log ids / from_expr + where) is run as a count(*) over the last 24 hours. status separates 'fix this' from 'wait for data': error = the monitor can't fire as built (no resolvable metric definition / orphaned, or a genuinely malformed query); warn = the query is VALID but has no data to act on — either zero events in the window, OR its target dataset/metric isn't present in this org yet (e.g. a from_expr metric collection that hasn't started flowing) — the monitor will fire once data arrives; ok = data present. So an erroring monitor needs fixing; a warn needs data. signal carries events_in_window, target_present (false when the dataset/metric is absent), and window. Read-only. Validates ALL monitors by default; pass monitor_ids to check specific ones. Returns {summary: {ok, warn, error}, results: [{monitor_id, name, status, reason, signal}]}.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/bronto-eu"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/bronto-eu)