Skip to main content
Glama

NEM Explorer (ScadaMiner)

Server Details

Query Australia's electricity market (NEM/AEMO): prices, generation, FCAS, interconnectors, bids.

Ownership verified

The last two health checks of this connector failed. If this server requires authentication, missing or expired test credentials may be the cause. A test profile lets Glama authenticate for health checks and discover tools; it is separate from your personal connections.

If you are the author, claim ownership, then add or update a test profile under Admin → Test Profile.

Status
Unhealthy
Uptime
31.8% over the last 24 hours
OAuth
Works in Glama
Last Tested
Transport
Streamable HTTP · MCP 2025-06-18
URL
Repository
brensch/scadaminer-ai-toolkit
GitHub Stars
0
ChatGPT
–
Claude
–

TDQS

A4.3/5.0

Scored across 26 tools

Disambiguation4/5

Each tool targets a distinct resource and action, and the descriptions actively cross-reference neighbours (export_data vs share_artifact vs share_dashboard, get_table_schema vs search_columns, get_dashboard vs list_dashboards). The remaining overlap is mild — build_chart also emerges implicitly from run_capability's chart_figure, and execute_sql/export_data/store_result all take SQL — but the text makes the boundaries explicit.

Naming Consistency5/5

All 26 tools follow a uniform snake_case verb_noun pattern (get_*, list_*, search_*, share_*, save_*, delete_*, run_*, build_*). Verb choice tracks intent consistently: get_ for single-object reads, list_ for collections, search_ for fuzzy lookup. No casing or style deviations anywhere.

Tool Count3/5

26 tools is heavy for a single server and sits just past the comfortable band, though the surface is genuinely broad (SQL, schema discovery, charts, scratch tables, dashboards, live URLs, publishing, documentation). Several tools are advisory/utility rather than operational — get_writing_style, get_concept, get_dashboard_guide, start_question, report_gap — which inflates the count beyond what the core workflow needs.

Completeness5/5

Full lifecycle is covered end to end: discovery (list_tables, search_columns, search_entities, get_table_schema, get_data_freshness), execution (execute_sql, store_result, fetch_result_rows, export_data), presentation (build_chart, save/get/list/delete_dashboard), and distribution (share_artifact, share_dashboard, pin_live_query, list_live_queries). Even failure paths have a channel (report_gap) and grounding docs (get_concept, get_writing_style, get_dashboard_guide).

Available Tools

26 tools
build_chartA
Read-onlyIdempotent
Inspect

PREFERRED INPUT: pass the result_id from an execute_sql response instead of columns/rows — the chart is then built from ALL rows of the result server-side (full fidelity, zero retyping). Inline columns/rows are only for small results that carried no result_id. Construct a web-ready Plotly chart spec from a query result. Pass the columns and rows from an execute_sql (or run_capability) result verbatim, plus the chart intent: chart_type (line/bar/area/scatter/pie/box/table/summary), title, x, one or more y columns, and optionally color (a grouping column — produces a stacked bar), y_label, series_labels, and analysis_shape (timeseries/distribution/ranking/breakdown/comparison/single_value). Legend entries are named after their y column unless you pass series_labels (one per y, same order). Column names are SQL identifiers, so whenever the label you want carries punctuation — % profitable, k=1.0, p95 dispatch error (MW), $/MW/yr — pass it in series_labels; a column alias cannot hold it. Only rows is truly required: columns may be omitted if you pass rows as JSON objects keyed by column name, and chart_type, title, x and y are all optional — when omitted they are inferred from the data shape (a line for a time/period axis, otherwise a bar, falling back to a table when the data isn't chartable). Supplying them is still preferred when you know the intent. Returns a renderer-tagged spec ({renderer, title, figure}) ready to hand to a Plotly frontend — identical to what the chat product renders, so no conversion is needed. A figure too big to inline (dozens of traces, thousands of points) comes back as a handle instead: chart_id, chart_url (the spec as JSON), a one-line summary and an outline of its traces and axes. Every column you reference in x/y/color must exist in columns. Use this after you've fetched data and the user wants a visualization (run_capability with execute:true already returns a chart_figure for capability results). To share or present a chart (or several), pass the returned spec(s) to share_artifact — do not build a PDF or slide deck locally.

Inputs: x, y, lat, lon, +14 more.

delete_dashboardA
Idempotent
Inspect

Delete one of the user's saved dashboards, by name or title. Only call this when they have explicitly asked for the dashboard itself to go, and quote their words in user_request — "this panel is wrong" is a save_dashboard edit, not a deletion. If you are not certain which one they meant, call list_dashboards and ask. The row is retained internally so support can restore a mistake, but it disappears from the user's page immediately.

Inputs: name (required), user_request (required), question_id.

execute_sqlA
Read-onlyIdempotent
Inspect

Execute a read-only ClickHouse SQL query and return the results. Send the whole analysis as ONE statement — arbitrarily complex read-only SQL is supported and preferred: multiple CTEs (WITH), self-joins, window functions, UNION ALL across horizons, and subqueries all run in a single call. There is no statement-complexity limit, and you do NOT need store_result/scratch tables to build up a multi-step result; reach for those only when you want to reuse an expensive intermediate across several later queries. Results are capped at 10000 rows returned (the cap applies to the rows handed back, not to how much the query may scan or aggregate). RESULT SHAPE: the response always leads with metadata — row_count (the FULL result size), preview_rows, and time_windows (the min/max of every time column across ALL rows) — followed by the rows. Results over the preview size (100 rows or 20 KB, whichever comes first, so wide rows show fewer) return only their first rows inline plus a result_id and result_url: the full result is parked server-side for 24h. NEVER re-run a query to see more of it. To aggregate/filter further, write new SQL (cheapest). For specific rows, fetch_result_rows(result_id, offset, limit). To chart EVERYTHING, pass result_id to build_chart — never retype rows. If you can execute code, download result_url (CSV) to a file and analyse it there — the data then costs you no context at all. When truncated=true the underlying query hit the row cap and even the parked result is incomplete: aggregate to daily/weekly/monthly. LIVE URL: every query over consolidated/semantic/calculated also returns a live_url. A plain GET on it re-runs THIS query and returns the latest rows as JSON — no API key, the id is the access. Point client-side chart code at it and the chart keeps updating wherever it is pasted (a static HTML file, an embedded widget, the user's own dashboard). It lasts 24h; pin_live_query makes it durable. Hand it over whenever a user wants a chart that stays current, and tell them anyone with the link can read it. VARIABLES: put {name:Type} placeholders in the SQL ({region:String}, {min_mw:Float64}, {regions:Array(String)}, {day:Date}) and give each a default in params — the query runs with those, and the live_url then accepts any value for each as a query string (?region=VIC1), checked against its type and bound by ClickHouse, never pasted into the SQL. $__timeFilter(ts) / $__timeGroup(ts) make it take from/to too. When a user wants a link they can point at other regions, units or windows, parameterise it this way rather than handing them one fixed query. For schema discovery do NOT query information_schema or system.* — use get_table_schema (one table's columns with types/units/notes) or search_columns (find columns by keyword); information_schema is not available on this connection. For data-coverage / date-range / latest-date questions ("how fresh is X", "what range does table Y cover", "earliest/latest date") do NOT hand-roll a scan — min/max(SETTLEMENTDATE) or DISTINCT date over a consolidated.* table reads the whole table and is rejected by a per-query resource cap. Use get_data_freshness (latest interval + NEM date) or list_tables (per-table data_available_from / data_available_to) instead. Every analytic query needs a time-column WHERE filter so ClickHouse can prune the primary key. The full NEM SQL reference (warehouse model, table mapping, dispatch conventions, formulas, ClickHouse syntax gotchas, join rules) is in the server's initial instructions — consult it before composing SQL.

Inputs: sql (required), time, params, question_id.

export_dataAInspect

DOWNLOAD or EXPORT query results as a private CSV file the user can open in Excel. THIS is the tool for "download it", "export it", "can I get this as a CSV/spreadsheet", "save this", "send me the data", or "give me the full data" — NOT share_artifact, which publishes to a public web page and will refuse a download request. Pass the read-only SELECT whose rows you want as sql (same rules and scan limits as execute_sql; to export a stored result use SELECT * FROM scratch.<scope>__<name> and include the same question_id you used there). Optionally pass a filename. The file holds up to 1000000 rows (and 24 MB), far more than execute_sql returns, because the rows go to the file and not back to you. So export the whole range the user asked for in ONE call and give them ONE link; do not split it by month or date range to stay under the execute_sql cap. Returns download_url — a private link, unlisted and not indexed, that expires in a day. Give it to the user and suggest they save the file. If the response carries truncated, the row cap was hit and the file is incomplete — say so, and offer to export the rest in date ranges. If it refuses with export too large, split exactly as it says: files_needed exports of at most max_rows_per_file rows, using suggested_split when given; do not guess a split of your own.

Inputs: sql (required), filename, question_id.

fetch_result_rowsA
Read-onlyIdempotent
Inspect

Page through a parked query result by its result_id (returned by execute_sql when a result exceeds the inline preview). Reads the stored snapshot — the exact rows the preview described, at zero warehouse cost and with no re-execution drift. Use this ONLY when you need to see specific raw rows beyond the preview; if what you actually want is a different aggregation or filter, write new SQL instead — it is cheaper and better. A page is capped at 20 KB as well as 1000 rows, so it can return fewer than limit: always continue from next_offset, never offset + limit. Handles expire after 24 hours; an expired id means re-running the SQL for a fresh one.

Inputs: result_id (required), limit, offset, question_id.

get_conceptA
Read-onlyIdempotent
Inspect

Read the authoritative explainer for an AEMO market mechanism before you describe how or why it works. Available topics: fpp, four_second_data, settlements, mlf, forecasts, fcas, constraints, over_constrained_dispatch, operating_margins, interconnectors, battery, curtailment, market_notices, bidding, demand, topology, outages, revenue, sra, vwap, price_setting, market_price_cap, market_price_floor, cumulative_price_threshold, multi_metric, participant_ownership, market_power. Call with an unknown topic to get the current list back. Each guide gives the precise terms and mechanics, the tables/columns that matter, how to aggregate, common pitfalls, and typical value ranges. Do NOT explain a mechanism's mechanics from your own knowledge — the plausible phrasing is often subtly wrong; ground the explanation in this guide or say you can't confirm it.

Inputs: topic (required), question_id.

get_dashboardA
Read-onlyIdempotent
Inspect

Read one saved dashboard's current spec — its queries and panels — by name or title. ALWAYS call this before editing one. save_dashboard replaces the whole spec rather than patching it, so an edit built from memory silently drops every panel you did not happen to remember. The response comes back in exactly the shape save_dashboard takes, so an edit is: get it, change the part the user asked about, send it all back. Its last_save is what the save behind this revision found — each query's cost, and any cost_warnings, data_warnings or empty_queries.

Inputs: name (required), question_id.

get_dashboard_guideA
Read-onlyIdempotent
Inspect

Read this BEFORE authoring or editing a saved dashboard for the first time in a session. Gives the full spec: the panel vocabulary (markdown / chart / table / stat), how queries are named and referenced, viewer-controlled parameters (region, date window), drill-through links between dashboards, shared CTEs, how a viewer extracts a panel's data as a table or CSV, and the rules whose violation gets a save refused. Cheap, and it is the difference between one save_dashboard call and three rejected ones.

Inputs: question_id.

get_data_freshnessA
Read-onlyIdempotent
Inspect

Return the warehouse's latest 5-minute SETTLEMENTDATE (the most recent data point present in dispatch-side tables) plus the current NEM time. Use this to bound date ranges in queries — anything past latest_settlementdate returns no rows. NEM time is Australia/Brisbane: UTC+10 with no daylight saving. Reach for this FIRST for any "how fresh / how current / latest date" question — never hand-roll max(SETTLEMENTDATE) over a consolidated table, which scans the whole table and is rejected by a per-query resource cap. For per-table availability bounds (the earliest date, or the range a specific table covers) use list_tables (data_available_from / data_available_to) — also scan-free.

Inputs: question_id.

get_table_schemaA
Read-onlyIdempotent
Inspect

Get the full column schema for a specific table, including AEMO-published metadata: per-column description, units, valid enum values, primary-key flags, and available_from (the MMSDM release month a column was added — present only for late-added columns like 1-second FCAS RRPs; don't query those for earlier dates). Also returns table-level documentation (description, source/volume notes, package id) and a curated selector block carrying the hard-learnt caveats, grain, join_keys, related_tables, and question_tags — read the caveats before composing SQL. Pass the exact object_name from list_tables. Use this once you've picked a table; for cross-table column lookup use search_columns.

Inputs: table_name (required), question_id.

get_writing_styleA
Read-onlyIdempotent
Inspect

READ THIS BEFORE WRITING ANY ANALYSIS THAT WILL BE PUBLISHED — before the note or blocks you pass to share_artifact, and before any write-up, report, article or post the user will put their name on. Takes no arguments. Returns the house writing guide: how to avoid the constructions that make analysis read as machine-written, which NEM terms are real and which are invented, and the rule that every number must trace back to a query you actually ran. Cheap, and it is the difference between analysis a market professional trusts and analysis they dismiss on sight. Not needed for ordinary short chat answers.

Inputs: question_id.

list_capabilitiesA
Read-onlyIdempotent
Inspect

List supported analytical capabilities. Each capability is a typed, deterministic product surface — given typed params it returns SQL, a chart spec, and (when applicable) a pre-rendered markdown answer. Identical to what the chat product runs internally, so capability output stays consistent across surfaces. Returns every capability's id and description. Pass the current user question (or a question_id from start_question) to get a matched_capability recommendation when the deterministic matcher identifies a fit: the exact capability_id, the params derived from the question, and that capability's params_contract (required fields, enums, defaults, aliases) and params_schema. Pass capability_id to get the same contract for any one capability.

Inputs: question, question_id, capability_id.

list_dashboardsA
Read-onlyIdempotent
Inspect

List the saved dashboards belonging to the signed-in user: name, title, panel count and URL. Call this FIRST whenever the user refers to a dashboard they already have ("update my price dashboard", "what dashboards do I have") — the names here are what get_dashboard, save_dashboard and delete_dashboard take. Private to the caller; there is no way to see anyone else's.

Inputs: question_id.

list_live_queriesA
Read-onlyIdempotent
Inspect

Every live query URL this user has, with what each is called, whether it is pinned or expiring, how often it has been fetched, and whether its SQL has started failing. Use it to answer "what live links do I have", to find the one a user means before pinning or revoking it, and to explain a chart of theirs that has stopped updating.

Inputs: question_id.

list_resultsA
Read-onlyIdempotent
Inspect

List the scratch tables you have stored via store_result, with each table's qualified_name (use it in execute_sql), row count, size, and time_window (the range its rows cover). Compare those windows: tables that should share a period and do not are a sign one was stored over too narrow a range. Pass your question_id from start_question — the listing is scoped to it. Call this to recall what intermediates you've already built before re-querying the warehouse.

Inputs: question_id.

list_tablesA
Read-onlyIdempotent
Inspect

List every available NEM data table from semantic.table_selector_index. By default returns the whole catalogue (one row per table) with a one-line curated summary per table, plus domain, time_column, and data-availability bounds (data_available_from / data_available_to). grain is omitted from the default view (the summary already encodes it) — pass detailed=true for it. A single call gives you the full warehouse map — no pagination, no truncation. Optional domain filter (bids, billing, constraints, demand, dispatch, fcas, forecasting, fpp, interconnectors, metering, mtpasa, network, operations, predispatch, pricing, registration, settlements, stpasa, trading) or keywords (case-insensitive substring across name/summary/description/tags) narrows the set when you already know what you want. Pass detailed=true to also include the full description, grain, key_columns, join_keys, related_tables, question_tags, and caveats. For full column metadata and curated caveats on one table, prefer get_table_schema.

Inputs: domain, detailed, keywords, question_id.

pin_live_queryA
Idempotent
Inspect

Keep a live query URL alive, name it, or kill it (#2374). Every execute_sql over the curated warehouse returns a live_url — a link that re-runs THAT query and returns the latest rows as JSON on a plain GET, with no API key, because the id in the link is the access and it grants only that one query. Those links last 24 hours. Pin one the moment a user is going to put it anywhere durable: a dashboard they host, an HTML file, an embedded widget, a chart they want to keep. Omit days for an indefinite link — that is usually what they want. Pass revoke: true to kill a link permanently; re-creating the same query then gives a DIFFERENT url, so the old one stays dead. Whenever you hand a user a live URL, tell them plainly that anyone with the link can read that data.

Inputs: live_url (required), days, label, revoke, +1 more.

report_gapA
Idempotent
Inspect

Tell the NEM Explorer team about something the user needed that these tools could not deliver. Optional and free: it costs no credits and does not change your answer. Call it ONLY when you were blocked, when a workaround failed, or when you had to give a narrower answer than the user asked for: the warehouse does not hold the data (missing_data), no tool or capability could do the job (missing_tool), the schema sent you down a wrong path (confusing_schema), or a tool returned something that looked wrong (wrong_result). Never call it on a question you answered in full, never as general feedback or praise, and at most once per gap per question. Pass the question_id from start_question, then wanted (what the user asked for that you could not deliver, with no names or other personal details) and tried (what you did instead). The user's answer comes first: report the gap alongside the answer, never instead of it.

Inputs: tried (required), wanted (required), category (required), question_id.

run_capabilityA
Read-onlyIdempotent
Inspect

Build (and optionally execute) a deterministic plan from a registered capability. Pass capability_id plus your question_id from start_question — the server re-derives the typed params from your question, so you can leave params as {} and don't need to know a capability's internal fields. Pass params only to refine a derived value (e.g. a specific region or date range); supplied keys override the derived ones. When you do send params, send only the fields params_contract marks required: everything else is optional, and the server applies schema defaults and rebuilds server_derived labels (chart titles, date-range prose, station and interconnector display names) from what you sent — never invent values for those. If something is genuinely missing you get every missing field back in one error, so one correction is enough. Returns the generated SQL, a chart spec, and a short data description — identical to what the chat pipeline would emit for the same capability. Pass execute: true to also run the SQL and get rows back (capped at the server's MCP_MAX_RESULT_ROWS limit) plus, when supported, a deterministic markdown answer. result has execute_sql's shape: a large result returns its first rows plus a result_id (page with fetch_result_rows, chart with build_chart); the answer and chart_figure are always built from every row. A chart_figure too big to inline comes back as a handle instead (chart_id, chart_url, summary, outline); see "Working with large results". Otherwise inspect the SQL and run it yourself with execute_sql.

Inputs: capability_id (required), params, execute, question_id.

save_dashboardAInspect

Create or update a saved dashboard: a live page NEM Explorer hosts for this user at a stable URL, whose panels re-run their queries against current data every time it is opened. THIS is the tool for "build me a dashboard", "can I have a page that tracks X", "add a chart to my Y dashboard", or anything the user wants to come back to. Not share_artifact — that publishes a one-off write-up to a PUBLIC page; a dashboard is private, live, and editable. You author a JSON document, not code: named read-only SQL queries plus panels (markdown, chart, table, stat) that reference them by name. A dashboard whose panels plot time should declare a time block — it gives the page a time picker and drag-to-zoom — and filter and bucket with $__timeFilter(ts) and $__timeGroup(ts). When the user wants to switch region on the page, declare params and read them in SQL as {region:String} rather than saving a dashboard per region; a detail page per row is one dashboard with a parameter plus a table links entry, not a dashboard per row. Call get_dashboard_guide for the vocabulary and the rules. To EDIT an existing one, call get_dashboard first and pass its name here along with the complete edited spec — a save REPLACES the spec, it does not merge. Passing name plus a different title renames it (and changes its URL). Every query is executed before anything is stored: if one fails, or a panel plots a column its query does not return, NOTHING is saved and you get every problem back at once, with the real column names. Fix them all and call again. Returns the url to give the user. A heavy dashboard can take a while to save. If this call times out, the save may still have landed: call get_dashboard. If its revision moved, its last_save carries that save's warnings. If it did not move (or a new dashboard does not exist), the save was refused or is still running and no reason is stored: save again to see why, with a narrower widest date option if a long window is the likely cause.

Inputs: title (required), ctes, name, time, +6 more.

search_columnsA
Read-onlyIdempotent
Inspect

Search column documentation by words, in any order and ignoring case, across column names, column descriptions and AEMO table names. Use this when you know what you want to measure but not which table holds it (e.g. 'marginal value', 'loss factor', 'intervention', 'RRP'). Spaces and hyphens also match underscored or run-together names: 'local price adjustment' finds LOCAL_PRICE_ADJUSTMENT and 'marginal value' finds MARGINALVALUE. Hits contain every word, best name matches first; if no column has every word, the closest partial matches come back with matched_all_terms=false. Each hit lists the AEMO source table, the column name + description + units + valid values, and the consolidated.* views that expose the column — pick one of those for your SQL. The docs cover AEMO's whole data model, including tables the warehouse does not hold: those hits carry in_warehouse=false and a not_in_warehouse_reason (participant-private, retired by AEMO, not yet published by AEMO, or not ingested), rank after warehouse hits, and cannot be queried.

Inputs: query (required), limit, question_id.

search_entitiesA
Read-onlyIdempotent
Inspect

Search the warehouse for entities that match a single term. Returns ranked candidates with similarity scores; the agent decides which (if any) the user meant. Entity types: duid (5-letter+ codes like ARWF1), station (station-level results that group all DUIDs at that station), region (canonical IDs NSW1/VIC1/QLD1/SA1/TAS1/SNOWY1), interconnector (Basslink, Heywood, QNI, VNI, Murraylink, Directlink, Project EnergyConnect), and fuel_type (Coal/Gas/Hydro/Wind/Solar/Battery/Biomass/Diesel). DUID matches also carry region, fuel_type, registered_capacity_mw and schedule_type (SCHEDULED/SEMI-SCHEDULED/NON-SCHEDULED), plus a note when the schedule type limits which tables hold rows for the unit: read it before querying bids, dispatch targets or constraints. Pick search terms from the user's question yourself. Call once per term — do not pass the whole question. Similarity is 0..1; treat scores below 0.7 with scepticism (the query term is probably a generic English word, not an entity reference).

Inputs: query (required), limit, types, question_id.

share_artifactAInspect

PUBLISHES analysis to a PUBLIC web page that ANYONE WITH THE LINK CAN READ — no sign-in, no account, not listed but not protected either. Treat calling this as pressing Publish on the user's behalf. Only call it when the user has explicitly asked to share, publish, or post this, and quote their words in user_request; if they have not, ask them first and tell them the page is public. A request to DOWNLOAD, EXPORT, or SAVE the data is NOT a request to publish it — return the data in your reply or as CSV instead, and expect this tool to refuse (#2212). When the user does want to publish, this is the native way to "make a presentation", "build a report/deck", "share this", or "post to LinkedIn/X/Reddit". USE THIS INSTEAD of generating a PDF, slide deck, or image file locally: it produces a live, interactive, branded web page (charts render with real Plotly), not a static file. Pass one chart as chart, or several as charts — each as the chart_id build_chart returned (preferred: a reference stays small, where several inlined figures can be truncated in transit), or as the chart object itself; rendered top to bottom — plus a title (headline shown on the page and the social preview card) and a note (markdown narrative tying the charts together). Call get_writing_style before composing that narrative: it is what keeps the page from reading as machine-written, and it carries the rule that every number must trace back to a query you ran. Returns {url, share_url}: url is the interactive page the user can OPEN AND EDIT (they can refine the title/wording and reorder/remove charts before posting); share_url is the link to post, which unfurls into a preview card. Tell the user they can edit the text on url before sharing, AND that the page is already public from this moment. The share is owned by the caller and revocable any time from the web app — though revoking cannot un-publish what someone already read. YOU must be signed in to create one; VIEWERS need no account, which is exactly why consent matters here. REVISING a page you already published: pass its token (or its URL) as token and send the whole write-up again. That rewrites the page at the SAME link, so a posted URL keeps working and no second page is left behind to revoke. Never republish a revision as a new page.

Inputs: user_request (required), note, chart, title, +4 more.

share_dashboardA
Idempotent
Inspect

Make one of the user's saved dashboards PUBLIC at an unguessable URL — or revoke that link with revoke: true. Anyone with the link sees the dashboard's LIVE warehouse data with no sign-in, served from a shared server-side cache so viewers cannot run up query costs. Only call this when the user has explicitly asked to share or publish the dashboard, and quote their words in user_request — the tool refuses otherwise, exactly like share_artifact. Idempotent: sharing twice returns the same URL. Revoking kills the link permanently; sharing again afterwards mints a NEW URL. The returned page accepts ?marquee=1 (chrome-free, for wall displays), &refresh=<seconds> (auto-refresh, min 30), and &panel=<n> (single panel). A request to host it on a search-friendly or SEO link counts as asking to share; once an admin lists it for search it is also served at the readable /nem/<slug> (see the dashboard guide). For a one-off analysis write-up use share_artifact instead — this is for a live page someone returns to.

Inputs: name (required), user_request (required), revoke, question_id.

start_questionAInspect

Register the user question you're about to answer. Returns a question_id (UUID). Pass that question_id as an argument on every subsequent tool call in this answer turn — the server will cluster those calls into one auditable trace. Optional but recommended; tool calls without question_id still work but receive a one-line reminder.

Inputs: question (required).

store_resultAInspect

Materialise a SELECT into a private scratch table you can re-query and JOIN in later execute_sql calls — without re-piping rows through the conversation. Use it as a scratchpad for multi-step analysis: pull a slice once, store it, then derive several things from it. Call start_question first and pass its question_id — the scratchpad is scoped to your question. Also pass a short name (lowercase letters/digits/underscores, e.g. gen_by_region) and the sql (a single read-only SELECT/WITH over consolidated.* / semantic.*, or over your own earlier scratch tables). The result lives in the scratch database; the returned qualified_name is what you reference later — e.g. SELECT ... FROM <qualified_name> JOIN consolidated.x ... (remember to pass the same question_id on that execute_sql call). Returns the schema, row count, a few sample rows (the full data stays in ClickHouse), and time_window — the range the stored rows actually cover. Check that window against the window your question is about: the table name records the measure, not the period, so a too-tight WHERE here is invisible later. Re-storing the same name overwrites it. Tables are private to your question, capped in count and size, and expire automatically. Prefer this over re-running a big query whenever you need an intermediate result in more than one later step.

Inputs: sql (required), name (required), question_id.

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      F
      maintenance
      One-call Australian energy-market plumbing via AEMO — cited, structured responses for market data and analysis, not a data broker.
      5
      196 PyPI
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI assistants to query and explain Australian National Electricity Market data from nemweb.com.au, covering price spikes, negative-price runs, interconnector flows and limits, binding constraints, and generation by fuel or unit, with live updates and every response stating its time convention, units, caveats, data freshness, and source AEMO file.
      AGPL 3.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Access Great Britain electricity grid open data from the NESO API, enabling queries about generation, demand, and market data.
      70 npm
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables querying Danish energy data—electricity prices, carbon intensity, consumption, production, grid capacity, balancing markets, and gas—from Energinet's public Energi Data Service without an API key.
      7
      MIT
    Try in Browser

    Glama MCP Gateway

    Add one secure layer between your agents and this server.