Skip to main content
Glama
822,234 tools. Updated 2026-11-22 23:08

"ClickHouse" matching MCP tools:

  • LAST RESORT — arbitrary READ-ONLY SQL against the Optimism transfers database. The Bitquery MCP specialized optimism_* tools are the PRIORITY; use this ONLY when none of them can answer (e.g. an uncovered table). No query optimizer here — naive SQL full-scans huge tables and JOINs time out. Runs read-only ClickHouse SQL. SQL reference: https://clickhouse.com/docs/reference/home FAST-QUERY RULES: filter on the indexed key tables — `optimism_api.transfers_sender` (by sender / outgoing), `optimism_api.transfers_receiver` (by receiver / incoming), `optimism_api.transfers_tx` (by tx hash); NEVER JOIN big tables — use `WHERE col IN (SELECT …)` (use `GLOBAL IN` when the subquery is referenced inside another subquery, otherwise its result is not available where it is used). A subquery that itself reads a transfers table (`IN (SELECT Transfer_Sender FROM …transfers_… WHERE …)`) is re-run for every shard and rescans that table — run it as its OWN query first, then pass the result back as a literal list (`IN (unhex('a'), unhex('b'))`). To filter transfers by a specific token, read `transfers_currency` (keyed by the token contract + `Block_Time`); `transfers_sender` / `transfers_receiver` are keyed by address, so filtering those by a token contract scans the table. Addresses are RAW BYTES `FixedString(20)` in `Transfer_Sender` / `Transfer_Receiver` (there are NO plain string address columns) → `Transfer_Sender = unhex(substring(lower('0x…'),3))`, output `concat('0x',lower(hex(col)))`. Tx hash is `Transaction_Hash` `FixedString(32)` (same unhex/hex pattern). A SET of hashes or addresses must have the column's exact type: `Transaction_Hash IN (SELECT toFixedString(unhex(h), 32) FROM …)`, `toFixedString(…, 20)` for an address. A plain `unhex(…)` set, or a JOIN on a String key, silently misses every value ending in `00`; `=` and a literal list `IN (unhex('a'), unhex('b'))` are safe. Currency symbol + decimals are INLINE columns (no dictionaries): amount = `toFloat64(Transfer_Amount) / pow(10, Transfer_Currency_Decimals)`; symbol = `Transfer_Currency_Symbol`; token contract = `Transfer_Currency_SmartContract` — itself RAW BYTES in a `String` column (not text), so filter it `= unhex('<40 hex, no 0x>')` and read it back `concat('0x',lower(hex(…)))`; a `'0x…'` text literal matches nothing. Always add `AND Transfer_Success = 1`. `Transfer_Type`: 'token' = a token transfer, 'transaction' = a plain native-coin send, 'call' = native coin moved by a call. A transaction's OWN value transfer is stored either as 'transaction' or as a 'call' with `Call_Index = 0`; only a 'call' with `Call_Index != 0` is an INTERNAL transfer (made by contract code deeper inside the transaction). For top-level transfers filter `(Transfer_Type IN ('token','transaction') OR (Transfer_Type = 'call' AND Call_Index = 0))` - `Transfer_Type IN ('token','transaction')` alone drops a large share of ordinary sends. Time = `Block_Time`. Date-time values come back as ISO-8601 UTC, e.g. 2026-09-21T15:04:18Z (toString() of a date-time gives 2026-09-21 15:04:18). Other `optimism_api.*` tables (calls, transactions, balances) are reachable with an explicit db prefix. Counterparty labels are NOT in this database — use labels_for_addresses. Read-only; always add a LIMIT of at most 10,000 — a larger answer fails with an error, so aggregate (GROUP BY, count) instead. 64-bit integers come back as JSON numbers, exact only up to 2^53: return a hash such as cityHash64(...) or any other 64-bit id as toString(x). Exact table and column names first: chain_list_tables, chain_describe_table and chain_search_columns with database=optimism_api.
    ConnectorOAuth
  • Query Point Topic's public broadband ontology (ClickHouse) — read-only. Exposes the public reference tables (the visitor view): the entity graph of ISPs, network operators, networks, links, link standards and their relationships. Discover tables with SHOW TABLES FROM ontology; inspect columns with DESCRIBE TABLE <name>. Licensed measurement data (footprints, premises, speeds, tariffs, forecasts, take-up, subscribers) is not queryable here and requires a Point Topic licence — denied queries return contact details. Only SELECT/WITH/SHOW/DESCRIBE/EXPLAIN allowed; returns CSV (large results are truncated at ~50k tokens with a leading notice — add LIMIT to keep results small).
    ConnectorNo auth
  • LAST RESORT — arbitrary READ-ONLY SQL against the Cardano databases (`cardano`, `cardano_flow`). The ada_* tools are the PRIORITY; use this ONLY when none can answer. No query optimizer here: filter on the per-key tables and NEVER JOIN big tables (use `IN (SELECT …)`); never GLOBAL IN (it reads the whole table). Runs read-only ClickHouse SQL. SQL reference: https://clickhouse.com/docs/reference/home This data runs on an older release of the engine: some functions and syntax in that reference (map() and toJSONString() among them) do not exist here — when a statement is refused for an unknown function or setting, use the forms shown in this description. DATA MODEL: UTXO model with native tokens — EVERY table has ONE ROW PER ASSET: `currency_id` (native ADA = 7029218, token_index = -1) and `value` UInt64 in RAW units. ALWAYS group by currency_id and divide by `dictGetFloat64('currency','divider',toUInt64(currency_id))` (1e6 for ADA; 1, i.e. raw units, for a token without registered decimals and for an unknown id); a plain sum(value) adds lovelace to token units and is meaningless, and sum() of large token values can overflow — sum toFloat64(value). TOKENS: token identity via the `currency` dict: 'symbol' / 'name' (a ticker or the hex asset name; '-' for an unknown id), 'asset_id' (fingerprint asset1…), 'decimals', 'properties' (YAML text; policy id = `extract(dictGetString('currency','properties',toUInt64(currency_id)), 'policyId: ([0-9a-f]{56})')`). Tickers are not unique — match tokens by fingerprint or policy id. A dictGet in WHERE runs for EVERY row read (no short-circuit), so filter by address / tx / currency_id first. Addresses are plain strings (`addr1…` bech32 lowercase, `stake1…` reward accounts, Byron base58 `Ae2…` / `Ddz…` case-sensitive); a script reward account (`stake17…` on explorers) is mostly recorded in its `stake1u…` spelling, whose checksum differs — look such an account up with ada_address_profile or ada_sent_from_address, which match both spellings. `stake_key` = the staking credential of a base address — on enterprise addresses (`addr1v…` / `addr1w…`) the column holds the payment credential re-encoded as `stake1u…`, which is NOT a staking key. Tx id: `tx_id_bin = unhex('<64hex>')`, output `hex(tx_id_bin)`. Time = `tx_time`. Date-times come back as 'YYYY-MM-DD hh:mm:ss' UTC; select formatDateTime(tx_time, '%FT%TZ') for ISO-8601 (2026-09-21T15:04:18Z), the shape the other tools return. TABLES: db `cardano`, partitioned by month on `tx_date` (add a plain `tx_date` bound whenever you can — inside `… OR …` it prunes nothing): inputs_by_address / outputs_by_address (key address; inputs carry output_tx_id_bin / output_index of the spent output and `source` Enum input/withdrawal/stake_deregistration; outputs carry `direction` — only not_change / unknown on ordinary outputs: change is NEVER labeled, so not_change includes change back to the payer), inputs_by_tx / outputs_by_tx / transactions (fee_value, deposit_value, metadata) / mints (key tx_id_bin — pass `(tx_date, tx_id_bin) IN (…)` when the date is known, otherwise every month is probed; to reuse one lookup in several UNION ALL branches write `(tx_date, tx_id_bin) IN identity((SELECT groupArray((tx_date, tx_id_bin)) FROM cardano.transactions WHERE tx_id_bin IN (…)))`, which runs once; `toInt64(value)` is negative for a burn), blocks (key block). Deposits are already rows: a stake registration is an output to the stake1… address (direction stake_registration), other protocol deposits an output with an empty address (deposit), a refund an input (stake_deregistration) — per transaction ADA inputs = outputs + fee_value and, per token, inputs + mints = outputs; do not add deposit_value on top. db `cardano_flow`: tx_inputs / tx_outputs keyed (block, tx_index), not partitioned — the cheap way to expand many transactions: `(block, tx_index) IN (SELECT block, tx_index FROM cardano.inputs_by_address WHERE address = '…')` (output_type commission / spend — never change; the commission row has an empty address). This copy is INCOMPLETE: it misses some transactions (a few hours of blocks in March 2023 among them) and most outputs of a token minted in the same transaction — use cardano.*_by_tx for exact per-transaction totals. address_transfers (AggregateFunction columns → -Merge; its amount columns ADD ALL ASSETS together and its stake_key is empty — use it for counts only). Address labels: none in this data — use labels_for_addresses(chain='cardano'). LIMITS: read-only; returns the rows of your query. 64-bit integers come back as JSON numbers, exact only up to 2^53: return a hash such as cityHash64(...) or any other 64-bit id as toString(x). A result of more than 25,000 rows is not cut off - the whole query fails with an error - so aggregate (GROUP BY, count) or add a LIMIT of at most 25,000.
    ConnectorOAuth
  • LAST RESORT — arbitrary READ-ONLY SQL against the BSC (Binance Smart Chain) transfers database. The Bitquery MCP specialized bsc_* tools are the PRIORITY; use this ONLY when none of them can answer (e.g. an uncovered table). No query optimizer here — naive SQL full-scans huge tables and JOINs time out. Runs read-only ClickHouse SQL. SQL reference: https://clickhouse.com/docs/reference/home FAST-QUERY RULES: filter on the indexed key tables — `bsc_api.transfers_sender` (by sender / outgoing), `bsc_api.transfers_receiver` (by receiver / incoming), `bsc_api.transfers_tx` (by tx hash); NEVER JOIN big tables — use `WHERE col IN (SELECT …)` (use `GLOBAL IN` when the subquery is referenced inside another subquery, otherwise its result is not available where it is used). A subquery that itself reads a transfers table (`IN (SELECT Transfer_Sender FROM …transfers_… WHERE …)`) is re-run for every shard and rescans that table — run it as its OWN query first, then pass the result back as a literal list (`IN (unhex('a'), unhex('b'))`). To filter transfers by a specific token, read `transfers_currency` (keyed by the token contract + `Block_Time`); `transfers_sender` / `transfers_receiver` are keyed by address, so filtering those by a token contract scans the table. Addresses are RAW BYTES `FixedString(20)` in `Transfer_Sender` / `Transfer_Receiver` (there are NO plain string address columns) → `Transfer_Sender = unhex(substring(lower('0x…'),3))`, output `concat('0x',lower(hex(col)))`. Tx hash is `Transaction_Hash` `FixedString(32)` (same unhex/hex pattern). A SET of hashes or addresses must have the column's exact type: `Transaction_Hash IN (SELECT toFixedString(unhex(h), 32) FROM …)`, `toFixedString(…, 20)` for an address. A plain `unhex(…)` set, or a JOIN on a String key, silently misses every value ending in `00`; `=` and a literal list `IN (unhex('a'), unhex('b'))` are safe. Currency symbol + decimals are INLINE columns (no dictionaries): amount = `toFloat64(Transfer_Amount) / pow(10, Transfer_Currency_Decimals)`; symbol = `Transfer_Currency_Symbol`; token contract = `Transfer_Currency_SmartContract` — itself RAW BYTES in a `String` column (not text), so filter it `= unhex('<40 hex, no 0x>')` and read it back `concat('0x',lower(hex(…)))`; a `'0x…'` text literal matches nothing. Always add `AND Transfer_Success = 1`. `Transfer_Type`: 'token' = a token transfer, 'transaction' = a plain native-coin send, 'call' = native coin moved by a call. A transaction's OWN value transfer is stored either as 'transaction' or as a 'call' with `Call_Index = 0`; only a 'call' with `Call_Index != 0` is an INTERNAL transfer (made by contract code deeper inside the transaction). For top-level transfers filter `(Transfer_Type IN ('token','transaction') OR (Transfer_Type = 'call' AND Call_Index = 0))` - `Transfer_Type IN ('token','transaction')` alone drops a large share of ordinary sends. Time = `Block_Time`. Date-time values come back as ISO-8601 UTC, e.g. 2026-09-21T15:04:18Z (toString() of a date-time gives 2026-09-21 15:04:18). Other `bsc_api.*` tables (calls, transactions, balances) are reachable with an explicit db prefix. Counterparty labels are NOT in this database — use labels_for_addresses. Read-only; always add a LIMIT of at most 10,000 — a larger answer fails with an error, so aggregate (GROUP BY, count) instead. 64-bit integers come back as JSON numbers, exact only up to 2^53: return a hash such as cityHash64(...) or any other 64-bit id as toString(x). Exact table and column names first: chain_list_tables, chain_describe_table and chain_search_columns with database=bsc_api.
    ConnectorOAuth
  • ESCAPE HATCH — read-only SQL for what NO tool answers: custom cohort backtests beyond launch_cohort, multi-step joins, quantiles. Check the tools first; they are keyed and far cheaper: - token_price, token_ohlcv, pair_ohlcv, currency_ohlcv, token_trade_bars (30 s to 1 h buy/sell bars) - new_tokens, launch_cohort, token_launch_stats, early_buyers, token_dex_venues, pool_recent_trades - trader_trades, trader_profile, trader_positions, trader_activity, top_traders_by_token - list_tables, describe_table, search_columns before writing a query - Hyperliquid (the perp exchange) is NOT in this database at all: its markets, funding, liquidations and traders are the hyperliquid_* tools, and its own hatch is hyperliquid_raw_sql After a tool answers, keep going with tools; use SQL only for the step none can do. Runs read-only ClickHouse SQL. SQL reference: https://clickhouse.com/docs/reference/home Scope: only the trading_rt database — DEX trades and 1 s to 1 h bars per token, pair, pool and currency, last ~30 days, 10 chains. Other visible databases are internal and unsupported: do not query them. Address labels and per-chain transfers are not here: use the label and <chain>_ tools. Rules: - Names are case-sensitive, not GraphQL fields or tool output names: trades_* use Pair_Token_Address / Pair_Token_Network / Pair_Token_Symbol (quote side Pair_QuoteToken_*), tokens_* and pairs_* Token_*; confirm with describe_table. - Use the *_by_<key> table that matches your filter, filter its leading sort keys, and on trades_* bound Block_Date too. - Bars: Interval_VolumeBased = 0; Price_IsQuotedInUsd = 1 for USD. - Windows on *_by_interval_start: enumerate the hour starts, Interval_Time_Start IN (SELECT arrayJoin(arrayMap(h -> toStartOfHour(now()) - toIntervalHour(h), range(24)))) AND Interval_Time_Duration = 3600; a >= range reads every duration. - One tokens_* hour can be stored twice: on multi-token scans add Token_Did = '' AND NOT (Volume_Usd = 0 AND LeadingPool_MarketId = '') (never on a single-address lookup: those rows can be a token's only rows); take the current and previous hour as argMax(Volume_Usd, Indexing_Time) per token; never GROUP BY Token_Name / Token_Symbol. - Amounts are decimal-adjusted; USD: AmountsInUsd_Base / AmountsInUsd_Quote / PriceInUsd; Side = what the trader received; Supply_MarketCap = the diluted value when Supply_CirculatingSupply = 0. - EVM addresses are lowercase 0x-hex, Solana/Tron base58 case-sensitive. Use UNION ALL; always add a LIMIT. Dates and times come back as ISO-8601 UTC (a Date as T00:00:00Z).
    ConnectorOAuth
  • LAST RESORT — arbitrary READ-ONLY SQL against the XRP Ledger (xrp, XRP, ripple, XRPL) data. Bitquery MCP xrp_* tools are the PRIORITY; use this ONLY when none can answer. No query optimizer here: account model — query the per-address tables `ripple_flow.transfers_from` (outgoing, key `transfer_from`) and `ripple_flow.transfers_to` (incoming, key `transfer_to`); per transaction `ripple.transfers_tx` (key `tx_hash_bin`). NEVER JOIN big tables (use `IN (SELECT …)`). Runs read-only ClickHouse SQL. SQL reference: https://clickhouse.com/docs/reference/home This data runs on an older release of the engine: some functions and syntax in that reference (map() and toJSONString() among them) do not exist here — when a statement is refused for an unknown function or setting, use the forms shown in this description. EVERY table is organized by month of `tx_date` back to 2013 and keyed only by address or hash: ALWAYS filter `tx_date` (e.g. `tx_date >= today() - 30`) or the query reads the whole history and may time out. Time = `tx_time`, ledger index = `block`; date-times come back as 'YYYY-MM-DD hh:mm:ss' UTC; select formatDateTime(t, '%FT%TZ') for ISO. Transfer columns: tx_hash_bin (binary — `hex(tx_hash_bin)` out, `unhex('…')` in), tx_type (Payment, OfferCreate, AccountDelete, CheckCash, EscrowFinish, …), transfer_from, transfer_to (classic r-addresses, case-sensitive), currency_from_id / value_from (what left the sender), currency_to_id / value_to (what the receiver got — the delivered amount), destination_tag (String, '0' = none), direction: 'payment' (account to account; from = to is a currency conversion), 'trade' (a filled offer, from = to), 'other' (one leg of an account deletion, check, escrow, payment channel, AMM, NFT sale or path rounding — exactly one of transfer_from / transfer_to is empty), 'nft_trade' / 'mint' / 'burn' (NFTs), 'fee' (one per signed transaction; a FAILED transaction leaves only its fee row, except an expired NFT offer acceptance that still lists an nft_trade row). Exclude fees with `direction != 'fee'`; for account-to-account flow use `direction = 'payment' AND transfer_from != transfer_to`. Amounts: amount = `value_from / dictGetFloat64('currency','divider',toUInt64(currency_from_id))` (XRP is currency id 413663, stored in drops, divider 1e6; issued tokens divider 1); code = `dictGetString('currency','symbol',toUInt64(id))` — 3-letter codes as text, others as 40-hex, NFT ids 64-hex (`splitByChar('\0', unhex(code))[1]` decodes e.g. RLUSD). A currency id is a CODE shared by every issuer of that code (counterfeit issuers included); transfer rows carry no issuer — it is in `ripple.payments_from` / `payments_to` / `payments_tx` (successful Payments: amount_*, delivered_*, send_max_* currency_id / value / issuer, tag, partial). Transaction status, fee (drops), memos, source_tag and signer: `ripple.transactions_tx` (key tx_hash_bin) and `ripple.transactions_sender` (key tx_sender) — result ('tesSUCCESS', 'tecPATH_DRY', …), success. Per-account balance changes, including the token issuer: `ripple.balances` (key account, currency_id). Also present: ripple.offers_*, escrows_tx, checks_tx, nftoken_offers_*, account_roots_tx — inspect with DESCRIBE TABLE first. No USD values; no inline labels (use labels_for_addresses with chain='ripple'). Read-only. 64-bit integers come back as JSON numbers, exact only up to 2^53: return a hash such as cityHash64(...) or any other 64-bit id as toString(x). A result of more than 25,000 rows is not cut off - the whole query fails with an error - so aggregate (GROUP BY, count) or add a LIMIT of at most 25,000.
    ConnectorOAuth

Matching MCP Servers

  • A
    license
    A
    quality
    D
    maintenance
    Enables AI assistants to query and manage ClickHouse databases, supporting SELECT queries, DDL/DML statements, and metadata listing.
    5
    3 npm
    MIT

Matching MCP Connectors

  • Browse, query, and administer your managed WaveHouse + ClickHouse projects (schema, pipes, policy).

  • Governed access to production AI-agent traces in an existing ClickHouse store.

  • Use this when the user asks an ad-hoc question that needs raw Search Console rows, like "top queries last 28 days" or "page-level performance for /pricing". Runs searchAnalytics.query on a property: date / query / page / country / device / searchAppearance dimensions, filters, and the web, image, video, news, discover, googleNews or all (combined) search type. Not for totals or period comparisons: use get_site_summary. Eligible requests are served from the GSC Wizard ClickHouse warehouse (longer history); searchAppearance, googleNews or 3+ distinct dimensions use the live Search Console API (`dataSource` says which). Rows are sorted by clicks, highest first, or by date then clicks when date is a dimension (a live-API result over 5,000 rows keeps clicks order); `sortedBy` states it. ctr is a 0-100 percentage. Query rows cover only the queries Google lists: `coverage.hiddenClicksShare` (0-1) is the share of clicks with no query row, so quote totals from `coverage.siteTotals`, or `coverage.filteredTotals` when `coverage.scope` is "filtered", not summed rows. searchAppearance rows cover only results with a special appearance and are not a split of the totals, so their hidden shares are null. Regex filters use RE2 (no lookahead or backreferences; use excludingRegex to exclude). Returns 100 rows by default: `pagination` says whether the result was truncated; page with startRow or raise rowLimit. Date range is optional: omit startDate/endDate to analyze the last 28 settled days (data lags ~2-3 days).
    ConnectorOAuth
  • Use this when the user asks how one specific page performed day by day. Daily performance for a single page (clicks, impressions, CTR, position). Useful for diagnosing post-deploy regressions on a specific URL. Not for a ranking of pages: use query_top_pages. `pageUrl` must match the URL exactly. Rows run by date, oldest first; days without impressions are absent, not zero. `ctr` is a 0-100 percentage. Served from the ClickHouse warehouse when available, otherwise the live Search Console API (see `dataSource`). Date range is optional: omit startDate/endDate to analyze the last 28 settled days (data lags ~2-3 days).
    ConnectorOAuth
  • Use this when the user asks how much visibility sits in the top 3, on page one or deeper: slices a property by where it ranks, using the same 1-3 / 4-10 / 11-20 / 21+ bands as the GSC Wizard dashboard. Not for CTR by position: use analyze_ctr_curve. granularity "period" (default) returns impressions, clicks and the number of queries (or pages) in each band over the whole range. granularity "daily" returns one row per day with the count of DISTINCT queries ranking in each band, to see a ranking shift build up or a drop land on a date. Bands run best first (1-3 to 21+) and days oldest first; ctr and the shares are 0-100 percentages. By query, counts and shares cover only the queries Google lists: on most properties a large share of clicks has no query row (analyze_sampling_impact measures it). Positions are impression-weighted averages, so a row sits in one band only. Served from the GSC Wizard ClickHouse warehouse when available (both views are computed over every query or page, never truncated; `scanLimit` is null there), otherwise from the live Search Console API over the top `scanLimit` rows by clicks, which drops zero-click rows first and so understates the deep bands when `truncated` is true (see `dataSource`). Date range is optional: omit startDate/endDate to analyze the last 28 settled days (data lags ~2-3 days).
    ConnectorOAuth
  • Use this when the user asks how their Merchant Center feed scored in the feed audit or which checks fail. Results of the Merchant Center feed audit for a GSC Wizard site: the latest run (or the run of a given runDate) with its status, Feed Score (0-100, split into scoreFeed and scorePage), failure counts by severity, per-check applicable / failed / passed counts with pass rates, offers audited, pages fetched and crawl coverage, plus the score history of earlier runs for the trend. checks run worst first (most failures), history newest first. coverage and the rates are 0-1 fractions (0.12 = 12%), not the 0-100 percentage ctr uses elsewhere. Not for Google's own item issues: use get_product_listing_status. checkKey narrows the checks list to one check; severity is accepted for parity with the app report, but the per-offer issue rows behind either filter live in the ClickHouse warehouse this server cannot read, so such a call answers `issuesAvailable: false`, pointing at the Feed Audit report in the GSC Wizard app. A run can cover several markets (one "<contentLanguage>~<feedLabel>" key each, e.g. "en~GB"): `run.markets` lists them, home market first, and `run.perMarket` gives each market's own offersAudited, score and severity counts; both are null on runs from before multi-market audits, and perMarket stays null until the run completes. The run-level score and checks combine every market the run covered; pass `market` with a key from run.markets to get that market's per-check counts in `checks` instead (a key the run does not cover answers a `marketNote` listing its markets, not an error). The owner picks the home market and up to 4 extra markets on the Feed Audit page in the GSC Wizard app; this server cannot change them. `run.crawlBlocked: true` means the page crawl stopped early because the site refused GSCWizard-Bot (401/403 or robots.txt), so the page-plane checks and scorePage cover few or no pages; allow the crawler and queue a new run. `run: null` means no audit has run yet, or none on runDate (queue one with run_feed_audit). `syncPaused` (with a one-line `staleNote`) means the Merchant Center sync is paused because Merchant Center no longer lets the connected Google account read the merchant: the stored results are still returned but may be stale, and `syncPaused.message` says how to fix it. `syncNotice` (reason "gmc_on_other_account") means Merchant Center is connected on another Google login than the property's Search Console one, so no new audit can run; stored results are still returned. Returns a `notConfigured` result (not an error) when Merchant Center is not connected, its credentials were revoked, no Merchant Center account is linked to the site, or (reason "gmc_on_other_account") no audit was ever stored because Merchant Center sits on another Google login.
    ConnectorOAuth
  • Fetch a single webmaster (affiliate NETWORK) by UUID: aggregate stats PLUS top_creatives — the creatives this webmaster re-uploads the MOST, ordered by the webmaster's OWN in-slice ad count (slice.ads_in_slice desc — the deliberate slice order, matching what the profile page shows), media stripped/free. Each entry's total_ads is the creative's market-wide family size, folded best-effort from family redirects and floored at ads_in_slice — total_ads == ads_in_slice therefore often means 'family cards not yet built', not 'this webmaster owns the whole market'; it is context, not the sort key. analytics_pending=true means the canonical PostgreSQL identity exists but its ClickHouse aggregate is not published yet, so zero counters are not analytical zeroes. fanpages_status explicitly reports advertiser-aligned lifecycle enrichment as available, partial, unavailable or not_applicable; an omitted fanpages array is therefore never evidence that a page is alive. The id MUST be the canonical UUID returned by search_webmasters; domain names and display names are rejected instead of silently widening to the whole database. Present top_creatives as the headline final step; for the rest of the network use search_creatives?webmaster_id / search_ads?webmaster_id, and download media with get_media (entity_type=creo). identifier_inventory_semantics explains why historical page/domain/pixel inventory counts are not comparable to total_ads. attribution_link_stats.merge_edges answers WHY these identifiers sit in one network: each entry is a {page_id, page_name, domain, ads} pair — that fanpage ran exactly that many ads on that landing domain, and such a pair is what merges two networks into one (an ad whose domain belongs to network A and whose fanpage belongs to network B fuses them permanently). Weigh the edges before claiming a single operator: a 1-3 ad edge next to 100+ ad edges is a thin bridge, typically a catalog/feed ad, and is weak evidence of shared ownership; identifiers with no edge at all are inherited from earlier merges and prove nothing today. QUOTA: 1 MCP credit (one entity card). TIKTOK: with source=tiktok this fetches the TikTok cluster card instead (business-id rollup, same UUID space as search_webmasters source=tiktok results) — ⚠️ costs 10 MCP credits and requires a Pro-or-higher plan; the Meta-only embeds (top_creatives, attribution link-stats) are omitted on the TikTok card. PRICING: on paid plans ×1 after 500 MCP credits/month; one-time consent via accept_pricing_terms; before calling, get the maximum debit from estimate_cost (free) and tell the user.
    ConnectorOAuth
  • 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.
    ConnectorOAuth
  • Use this when the user asks an ad-hoc question that needs raw Search Console rows, like "top queries last 28 days" or "page-level performance for /pricing". Runs searchAnalytics.query on a property: date / query / page / country / device / searchAppearance dimensions, filters, and the web, image, video, news, discover, googleNews or all (combined) search type. Not for totals or period comparisons: use get_site_summary. Eligible requests are served from the GSC Wizard ClickHouse warehouse (longer history); searchAppearance, googleNews or 3+ distinct dimensions use the live Search Console API (`dataSource` says which). Rows are sorted by clicks, highest first, or by date then clicks when date is a dimension (a live-API result over 5,000 rows keeps clicks order); `sortedBy` states it. ctr is a 0-100 percentage. Query rows cover only the queries Google lists: `coverage.hiddenClicksShare` (0-1) is the share of clicks with no query row, so quote totals from `coverage.siteTotals`, or `coverage.filteredTotals` when `coverage.scope` is "filtered", not summed rows. searchAppearance rows cover only results with a special appearance and are not a split of the totals, so their hidden shares are null. Regex filters use RE2 (no lookahead or backreferences; use excludingRegex to exclude). Returns 100 rows by default: `pagination` says whether the result was truncated; page with startRow or raise rowLimit. Date range is optional: omit startDate/endDate to analyze the last 28 settled days (data lags ~2-3 days).
    ConnectorAPI key
  • Use this when the user asks how one specific page performed day by day. Daily performance for a single page (clicks, impressions, CTR, position). Useful for diagnosing post-deploy regressions on a specific URL. Not for a ranking of pages: use query_top_pages. `pageUrl` must match the URL exactly. Rows run by date, oldest first; days without impressions are absent, not zero. `ctr` is a 0-100 percentage. Served from the ClickHouse warehouse when available, otherwise the live Search Console API (see `dataSource`). Date range is optional: omit startDate/endDate to analyze the last 28 settled days (data lags ~2-3 days).
    ConnectorAPI key
  • Use this when the user asks how much visibility sits in the top 3, on page one or deeper: slices a property by where it ranks, using the same 1-3 / 4-10 / 11-20 / 21+ bands as the GSC Wizard dashboard. Not for CTR by position: use analyze_ctr_curve. granularity "period" (default) returns impressions, clicks and the number of queries (or pages) in each band over the whole range. granularity "daily" returns one row per day with the count of DISTINCT queries ranking in each band, to see a ranking shift build up or a drop land on a date. Bands run best first (1-3 to 21+) and days oldest first; ctr and the shares are 0-100 percentages. By query, counts and shares cover only the queries Google lists: on most properties a large share of clicks has no query row (analyze_sampling_impact measures it). Positions are impression-weighted averages, so a row sits in one band only. Served from the GSC Wizard ClickHouse warehouse when available (both views are computed over every query or page, never truncated; `scanLimit` is null there), otherwise from the live Search Console API over the top `scanLimit` rows by clicks, which drops zero-click rows first and so understates the deep bands when `truncated` is true (see `dataSource`). Date range is optional: omit startDate/endDate to analyze the last 28 settled days (data lags ~2-3 days).
    ConnectorAPI key
  • Use this when the user asks how their Merchant Center feed scored in the feed audit or which checks fail. Results of the Merchant Center feed audit for a GSC Wizard site: the latest run (or the run of a given runDate) with its status, Feed Score (0-100, split into scoreFeed and scorePage), failure counts by severity, per-check applicable / failed / passed counts with pass rates, offers audited, pages fetched and crawl coverage, plus the score history of earlier runs for the trend. checks run worst first (most failures), history newest first. coverage and the rates are 0-1 fractions (0.12 = 12%), not the 0-100 percentage ctr uses elsewhere. Not for Google's own item issues: use get_product_listing_status. checkKey narrows the checks list to one check; severity is accepted for parity with the app report, but the per-offer issue rows behind either filter live in the ClickHouse warehouse this server cannot read, so such a call answers `issuesAvailable: false`, pointing at the Feed Audit report in the GSC Wizard app. A run can cover several markets (one "<contentLanguage>~<feedLabel>" key each, e.g. "en~GB"): `run.markets` lists them, home market first, and `run.perMarket` gives each market's own offersAudited, score and severity counts; both are null on runs from before multi-market audits, and perMarket stays null until the run completes. The run-level score and checks combine every market the run covered; pass `market` with a key from run.markets to get that market's per-check counts in `checks` instead (a key the run does not cover answers a `marketNote` listing its markets, not an error). The owner picks the home market and up to 4 extra markets on the Feed Audit page in the GSC Wizard app; this server cannot change them. `run.crawlBlocked: true` means the page crawl stopped early because the site refused GSCWizard-Bot (401/403 or robots.txt), so the page-plane checks and scorePage cover few or no pages; allow the crawler and queue a new run. `run: null` means no audit has run yet, or none on runDate (queue one with run_feed_audit). `syncPaused` (with a one-line `staleNote`) means the Merchant Center sync is paused because Merchant Center no longer lets the connected Google account read the merchant: the stored results are still returned but may be stale, and `syncPaused.message` says how to fix it. `syncNotice` (reason "gmc_on_other_account") means Merchant Center is connected on another Google login than the property's Search Console one, so no new audit can run; stored results are still returned. Returns a `notConfigured` result (not an error) when Merchant Center is not connected, its credentials were revoked, no Merchant Center account is linked to the site, or (reason "gmc_on_other_account") no audit was ever stored because Merchant Center sits on another Google login.
    ConnectorAPI key
  • Provisions a managed MySQL (or MariaDB) database on a dedicated VM on your private network - the relational-database resource (use this instead of create_database when the app needs MySQL/MariaDB, e.g. WordPress, NextCloud, Matomo, many PHP/LAMP apps). Requires a recent plan_managed_datastore. For app deployments, prefer deploy_app database:'managed' with db_engine mysql/mariadb so plan_deploy includes and wires the DB automatically. It is PRIVATE - reachable only from another instance on the same private network, via the DB's internal/private IP (port 3306), not a public address. Get the ids from plan_managed_datastore/list_flavors/list_private_networks/list_keypairs. Provisioning takes ~5 min; poll list_relational_databases until status='ready', then the connection details (private_ip, port 3306, db_name, db_user) are populated. MySQL is created with mysql_native_password auth so older clients/apps connect cleanly. (ClickHouse is a separate resource - use create_clickhouse / list_clickhouse_databases.)
    ConnectorNo auth
  • Aggregated trace statistics for one agent over the last N days — total runs, success rate, avg duration, error breakdown, top tools used, runs-per-day histogram, and what the agent spent. `spend` totals the agent's LLM usage over the same window: `llm_calls`, `tokens_input`, `tokens_output`, `cost_usd`, and `own_key_cost_usd` (the slice paid with the workspace's own vendor key, included in cost_usd rather than added to it). It covers usage recorded since per-agent attribution shipped, so it reads 0 for older runs; null means the lookup could not run. Use this when you want a bird's-eye view of an agent's health before diving into individual traces with `agents.traces_list` / `agents.trace_get`. Scoped to the target agent (exact match, no substring bleed). `days` is capped at 30 — matches the ClickHouse request_traces TTL.
    ConnectorAPI key
  • Aggregated trace statistics for one agent over the last N days — total runs, success rate, avg duration, error breakdown, top tools used, runs-per-day histogram, and what the agent spent. `spend` totals the agent's LLM usage over the same window: `llm_calls`, `tokens_input`, `tokens_output`, `cost_usd`, and `own_key_cost_usd` (the slice paid with the workspace's own vendor key, included in cost_usd rather than added to it). It covers usage recorded since per-agent attribution shipped, so it reads 0 for older runs; null means the lookup could not run. Use this when you want a bird's-eye view of an agent's health before diving into individual traces with `agents.traces_list` / `agents.trace_get`. Scoped to the target agent (exact match, no substring bleed). `days` is capped at 30 — matches the ClickHouse request_traces TTL.
    ConnectorAPI key
  • Aggregated trace statistics for one agent over the last N days — total runs, success rate, avg duration, error breakdown, top tools used, runs-per-day histogram, and what the agent spent. `spend` totals the agent's LLM usage over the same window: `llm_calls`, `tokens_input`, `tokens_output`, `cost_usd`, and `own_key_cost_usd` (the slice paid with the workspace's own vendor key, included in cost_usd rather than added to it). It covers usage recorded since per-agent attribution shipped, so it reads 0 for older runs; null means the lookup could not run. Use this when you want a bird's-eye view of an agent's health before diving into individual traces with `agents.traces_list` / `agents.trace_get`. Scoped to the target agent (exact match, no substring bleed). `days` is capped at 30 — matches the ClickHouse request_traces TTL.
    ConnectorAPI key
  • LAST RESORT — arbitrary READ-ONLY SQL against the Arc transfers database. The Bitquery MCP specialized arc_* tools are the PRIORITY; use this ONLY when none of them can answer (e.g. an uncovered table). No query optimizer here — naive SQL full-scans huge tables and JOINs time out. Runs read-only ClickHouse SQL. SQL reference: https://clickhouse.com/docs/reference/home FAST-QUERY RULES: filter on the indexed key tables — `arc_api.transfers_sender` (by sender / outgoing), `arc_api.transfers_receiver` (by receiver / incoming), `arc_api.transfers_tx` (by tx hash); NEVER JOIN big tables — use `WHERE col IN (SELECT …)` (use `GLOBAL IN` when the subquery is referenced inside another subquery, otherwise its result is not available where it is used). A subquery that itself reads a transfers table (`IN (SELECT Transfer_Sender FROM …transfers_… WHERE …)`) is re-run for every shard and rescans that table — run it as its OWN query first, then pass the result back as a literal list (`IN (unhex('a'), unhex('b'))`). To filter transfers by a specific token, read `transfers_currency` (keyed by the token contract + `Block_Time`); `transfers_sender` / `transfers_receiver` are keyed by address, so filtering those by a token contract scans the table. Addresses are RAW BYTES `FixedString(20)` in `Transfer_Sender` / `Transfer_Receiver` (there are NO plain string address columns) → `Transfer_Sender = unhex(substring(lower('0x…'),3))`, output `concat('0x',lower(hex(col)))`. Tx hash is `Transaction_Hash` `FixedString(32)` (same unhex/hex pattern). A SET of hashes or addresses must have the column's exact type: `Transaction_Hash IN (SELECT toFixedString(unhex(h), 32) FROM …)`, `toFixedString(…, 20)` for an address. A plain `unhex(…)` set, or a JOIN on a String key, silently misses every value ending in `00`; `=` and a literal list `IN (unhex('a'), unhex('b'))` are safe. Currency symbol + decimals are INLINE columns (no dictionaries): amount = `toFloat64(Transfer_Amount) / pow(10, Transfer_Currency_Decimals)`; symbol = `Transfer_Currency_Symbol`; token contract = `Transfer_Currency_SmartContract` — itself RAW BYTES in a `String` column (not text), so filter it `= unhex('<40 hex, no 0x>')` and read it back `concat('0x',lower(hex(…)))`; a `'0x…'` text literal matches nothing. Always add `AND Transfer_Success = 1`. DO NOT copy the `Transfer_Type IN ('token','transaction')` filter used on other chains — here it drops almost every USDC movement. `Transfer_Type`: 'token' = a log, 'transaction' = a plain value send, 'call' = a value move read from the call trace, which is how most USDC moves. A transaction's OWN transfer is a 'call' with `Call_Index = 0`, so "internal" is `Transfer_Type = 'call' AND Call_Index != 0`, never `Transfer_Type = 'call'` alone. USDC IS ONE ASSET WITH TWO INTERFACES sharing one balance: the native coin (`Transfer_Currency_Native = 1`, empty contract, 18 decimals) and the ERC-20 at 0x3600000000000000000000000000000000000000 (6 decimals). Each movement appears once, under the interface used, so `Transfer_Currency_Native = 1 OR Transfer_Currency_SmartContract = unhex('3600000000000000000000000000000000000000')` is the whole USDC flow. ALWAYS EXCLUDE `Transfer_Currency_SmartContract = unhex('fffffffffffffffffffffffffffffffffffffffe')`: that address only repeats a USDC movement already present (up to 2026-09-18), so leaving it in counts USDC twice. Over a thousand other contracts print the symbol USDC and are unrelated tokens. Time = `Block_Time`; history starts in May 2026. Date-time values come back as ISO-8601 UTC, e.g. 2026-09-21T15:04:18Z (toString() of a date-time gives 2026-09-21 15:04:18). Other `arc_api.*` tables (calls, transactions, balances) are reachable with an explicit db prefix. `arc_api.dex_trades_tx` holds this chain's DEX trades from 2026-05-27, earlier than the trade tools reach, and is the only way at that first period. In the `balances_*` tables `Balance_Amount` is an aggregate state, not a number — read it as `reinterpretAsInt256(argMaxMerge(Balance_Amount))` with a GROUP BY, or it comes back as unreadable bytes. Counterparty labels are NOT available for this chain — describe an address from its transfer profile instead. Read-only; always add a LIMIT of at most 10,000 — a larger answer fails with an error, so aggregate (GROUP BY, count) instead. 64-bit integers come back as JSON numbers, exact only up to 2^53: return a hash such as cityHash64(...) or any other 64-bit id as toString(x). Exact table and column names first: chain_list_tables, chain_describe_table and chain_search_columns with database=arc_api.
    ConnectorOAuth