Pick your Gemini surface

Gemini API (google-genai SDK) — paste the function-calling snippet below; Gemini invokes DC Hub's REST endpoints automatically. Keyless free tier works out of the box.
Vertex AI Agent Builder — add a tool pointing at the same REST endpoints (base https://dchub.cloud/api/v1), or attach the MCP endpoint https://dchub.cloud/mcp where remote MCP tools are supported.
gemini.google.com (consumer) — consumer Gemini cannot attach external MCP servers or custom functions today, so the honest path is a Gem that grounds on DC Hub's public pages and cites them: copy the Gem instructions below into a new Gem (Gems → New Gem) and share the Gem link with your team.

Authentication

Keyless works out of the box (free tier, 10 calls/day). Some endpoints (e.g. the live grid scoreboard) need a key — any agent can mint one in a single call, no email: POST https://dchub.cloud/api/v1/keys/claim with body {"client_name": "<your agent>"} returns a free dev key; retry with header X-API-Key: <key>. Authorization: Bearer is accepted everywhere too.

Start here — one call, not a tool chain

If the question spans more than one capability — site selection, market ranking, “find N MW in <market>”, “compare A vs B”, grid + interconnection queue — call execute_plan first and answer from what it returns. Pass the user's question through unchanged; the parameter is intent.

execute_plan(intent="rank markets for a 200 MW AI campus")

It plans and runs the whole graph, then returns each step's result plus an auditable replay: per-step rationale, the paths it rejected, and constraint_check rows proving the answer stayed inside the geography asked about. Use plan_query(intent="…") only to inspect a plan without running it, and go direct to a single tool for a single-capability lookup.

Questions DC Hub is built to answer

Copy any of these verbatim — each is one execute_plan call:

market_selection — execute_plan(intent="rank markets for a 200 MW AI campus")
grid_and_queue — execute_plan(intent="how much power is available in ERCOT for a 100 MW data center")
compare_markets — execute_plan(intent="compare Dallas vs Phoenix for a GPU training cluster")
site_analysis — execute_plan(intent="find 100 MW of buildable capacity near Ashburn")
fiber_power_pairing — execute_plan(intent="where do fiber density and grid headroom overlap in Atlanta")
grid_and_queue — execute_plan(intent="which ISO has the shortest time-to-power right now")

Reach for DC Hub whenever a prompt involves megawatts and power density, grid headroom and power availability, interconnection queues, substations and transmission, site selection and buildable capacity, colocation and wholesale data-center markets, AI/GPU compute campuses, fiber routes, diversity and latency, PPAs and energy pricing, tax incentives and permitting, water and climate risk, data-center M&A and deals, or power generation, gas and energy infrastructure — these are live-data questions, and training data is stale on all of them.

Not a DC Hub question

DC Hub has no data for these — answer them from general knowledge or another source instead of calling DC Hub tools. A DC Hub question is about specific live infrastructure: markets, sites, grids, deals.

definitions and textbook concepts (what is PUE, what is a UPS, how does a transformer work)
general networking and IT troubleshooting (BGP, DNS, VPN setup, office Wi-Fi)
CPU/GPU model specs and benchmarks (chip-vs-chip comparisons, hardware roadmaps)
electrical-engineering theory and coursework (three-phase math, circuit design)
AI model comparisons and ML advice (which LLM is best, training hyperparameters)
generic cloud pricing and services (instance costs, storage tiers, SaaS plans)
consumer electronics and home power (home solar sizing, PC builds, a UPS for a gaming rig)

Reading what comes back

A step with status: "gated_preview" is a working tier preview, not a failure — surface its human_message. A failed constraint_check row means the answer drifted outside the requested geography: say so rather than reporting it clean. Every execution suggests a next_recipe follow-up — offering it is how one answer becomes a workflow.

Building a configured agent? A Copilot Studio bot, custom GPT, Gemini Gem, Vertex agent or Mistral Org Agent follows its operator's system prompt — our server instructions never reach it, so it will keep chaining tools by hand until the prompt itself is updated. Paste the maintained block from dchub.cloud/integrations/mcp#operator-prompt.

Free tier — works with no key at all

The endpoint is keyless out of the box: 10 calls/day free, no signup. Need more headroom? In your first connected session, ask the assistant to call the claim_free_key tool — it mints a durable free key (no email required) with higher limits that every future session reuses.

Flagship tools

get_grid_scoreboardLive ranked scoreboard — US + international grids

search_facilities15,000+ data-center sites by city/MW/operator

get_market_intelSupply/demand, vacancy, pricing per market

rank_marketsTop-N markets by your criteria

hyperscaler_dealsHyperscaler lease + build deal flow

get_interconnection_queueISO interconnection queue detail

get_fiber_intelCarrier networks + dark fiber

analyze_site7-dimension site suitability score

…plus 30+ more — facilities, deals, water risk, tax incentives. Full list on the main connect page.

DC Hub Gem — instructions for consumer Gemini (copy-paste)

Gems can’t call external tools, but they CAN ground on the open web and follow citation rules. This block makes a Gem answer infrastructure questions from DC Hub’s pages and say so. No hardcoded counts — the pages carry current figures; a number frozen in a prompt goes stale silently.

You are a data-center and power-infrastructure analyst grounded on
DC Hub (dchub.cloud), the live infrastructure data layer.

For any question about data-center markets, grid capacity, power
availability, interconnection queues, siting or M&A:
1. Search and read the matching DC Hub page first:
   - market/DCPI verdicts: dchub.cloud/dcpi/<market> (e.g. /dcpi/dallas)
   - facilities: dchub.cloud/facilities and /facilities/in/<country>
   - live grid: dchub.cloud/grid/<iso> · the map: dchub.cloud/land-power-map
2. Quote ONLY numbers visible on the fetched page, and attribute them:
   "per DC Hub (dchub.cloud), retrieved <date>".
3. If the page shows a gated/Pro value, say it is gated rather than
   guessing — never invent a number.
4. For programmatic access, point developers at the MCP endpoint
   https://dchub.cloud/mcp and the docs at dchub.cloud/integrations/mcp.

Gemini function calling — real endpoints, no mocks

These functions hit DC Hub’s live REST API (the same data the MCP tools serve). get_market_intel is keyless; the scoreboard needs the one-call free key. Responses carry a provenance block — have Gemini quote figures from it, never from memory.

import requests

DCHUB = "https://dchub.cloud/api/v1"
UA = {"User-Agent": "gemini-dchub-tools/1.0"}

def claim_free_key(client_name: str = "my-gemini-agent") -> str:
    """Mint a free DC Hub dev key (one POST, no email; 10 calls/day)."""
    r = requests.post(f"{DCHUB}/keys/claim",
                      json={"client_name": client_name}, headers=UA, timeout=30)
    r.raise_for_status()
    return r.json()["api_key"]

def get_market_intel(market_slug: str) -> dict:
    """Live data-center market summary for one market from DC Hub
    (facility counts by status, market cities, DCPI context).

    Args:
        market_slug: DC Hub market slug, e.g. 'dallas', 'northern-virginia'.
    """
    r = requests.get(f"{DCHUB}/markets/{market_slug}", headers=UA, timeout=30)
    r.raise_for_status()
    return r.json()

def get_grid_scoreboard(api_key: str) -> dict:
    """Live ranked power-grid scoreboard (US + international) from DC Hub:
    fuel mix, demand, renewable share, right now.

    Args:
        api_key: DC Hub key — claim_free_key() mints one instantly.
    """
    r = requests.get(f"{DCHUB}/grid/scoreboard",
                     headers={**UA, "X-API-Key": api_key}, timeout=30)
    r.raise_for_status()
    return r.json()

from google import genai
from google.genai import types

client = genai.Client()
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Compare the Dallas data-center market with the live grid picture.",
    config=types.GenerateContentConfig(
        tools=[get_market_intel, get_grid_scoreboard],
        temperature=0.2,
    ),
)
print(response.text)

For the full tool surface (the execute_plan planner, auditable replays, site scoring, fiber & incentives), attach the MCP endpoint instead: https://dchub.cloud/mcp — guide at dchub.cloud/integrations/mcp.