AgenticGeoMate

Australian geoscience data for agents: exploration reports, drillholes, geochemistry, WA mineral prospectivity and read-only SQL. Remote server with OAuth sign-in (free account). Built by AI4WA and UWA NTLP.

託管 MCP 伺服器

npx add-mcp 'https://geomate.nlp-tlp.org/mcp'

可安裝到 Claude Code、Codex、Cursor 等客戶端

文件

One REST API over the whole database. Sign in, get a token, then follow the guides below; the full reference is at the end. GIS users can add the public layers straight from the OGC service at /ogc.

Quick start

Create a personal token on your account page, install the Python client, ask. Or send the token as a bearer from anything that speaks HTTP.

pip install "git+https://github.com/PascalSun/[email protected]"
from ntlp_geodata import GeoData
gd = GeoData(token="gp_your_token_here")
print(gd.nearby(121.5, -30.7, radius_km=10))
curl "https://platform.nlp-tlp.org/geo/api/nearby/?lon=121.5&lat=-30.7" -H "Authorization: Bearer <token>"

Agents

The same data as MCP tools, for Claude, Cursor or your own agent. Sign in with a platform account when the client asks.

https://geomate.nlp-tlp.org/mcp

Getting the data, step by step

Start at the top and each guide hands you what the next one needs. Get data with the Python client; build your own site with the web client.

[

Python client — get the data ↗︎

For notebooks and scripts: every guide below, paging and rate limits handled.

pip install "git+https://github.com/PascalSun/[email protected]"](https://github.com/PascalSun/ntlp-geodata)[

Web client — build a site on the platform ↗︎

For your own web app: the platform’s sign-in and authenticated calls, as MineTrace and CoreFlagging use them.

"@ntlp/geodata-web": "github:PascalSun/ntlp-geodata-web"](https://github.com/PascalSun/ntlp-geodata-web)

  1. 01

    Sign in and get a token

    Everything but the summary and the tiles needs a token. For scripts and notebooks, create a personal token on your account page: Read covers every query, Read and write also uploads and edits your data, and it can expire after 30, 90 or 365 days. For an app that signs people in, use the sign-in code and refresh flow. With a token you may make 600 requests a minute (SQL 30, exports 10 an hour); past that the answer is 429 with a Retry-After.
    pip install "git+https://github.com/PascalSun/[email protected]"
    from ntlp_geodata import GeoData
    gd = GeoData(token="gp_your_token_here")   # a personal token from https://geo.nlp-tlp.org/map?panel=account#tokens
    gd.me()                                     # or set GEODATA_TOKEN and call GeoData()
    # every call below follows pages for you and waits out a 429
    
    Now you have: A bearer token for every call below, and a refresh token to renew it.
  2. 02

    See what is there

    Before pulling anything, see how much the platform holds and which datasets exist, with their licences.
    gd.summary()                 # no token needed
    gd.catalog(q="drill")          # the data catalogue behind https://geo.nlp-tlp.org/data
    gd.search("A38751")            # a report, hole, tenement or site by its id
    
    Now you have: The counts you see on the front page, and the dataset list behind https://geo.nlp-tlp.org/data.
  3. 03

    Data around a point

    The commonest question: what is known near here? One call returns drillholes, samples, assay highlights, reports and tenure within a radius.
    near = gd.nearby(121.47, -30.75, radius_km=5, metal="Au")
    for f in gd.nearby_points(121.47, -30.75, radius_km=5, kind="drillhole"):
        print(f["properties"])     # GeoJSON features, every page
    
    Now you have: A summary of the ground around the point, and the points themselves as GeoJSON.
  4. 04

    Data under a region

    For an area rather than a point: a bounding box gives counts and headline figures; a polygon gives the assays as a file.
    gd.region_summary(121.3, -30.9, 121.7, -30.5, metal="Au")
    ring = [(121.3, -30.9), (121.7, -30.9), (121.7, -30.5), (121.3, -30.5)]
    gd.geochem_export("company_dh_collars", ring, "collars.zip")    # EarthBank-ready zip
    job = gd.export("drillholes", bbox=(121.3, -30.9, 121.7, -30.5), format="csv")
    gd.download(job["url"], "drillholes.csv")
    
    Now you have: Figures for the region, the geochemistry inside your polygon as a zip, and a download of the layer under it.
  5. 05

    Reports and documents

    Every WAMEX report has been read page by page. Find the reports that cover a place, then fetch their files.
    for r in gd.wamex(121.47, -30.75, nearby=True, radius_km=10):   # every page
        print(r["anumber"], r["year"], r["title"])
    files = gd.report_files("A38751")        # PDF and data-file links
    gd.doc_files("A38751")                   # every file of one document
    gd.download_reports(["A38751", "A6467"], "wamex/")   # every file of many reports into wamex/A<n>/, resumable
    
    Now you have: The reports for a place (count is the total, page.next the rest) and download URLs for their PDFs and data files. The WAMEX mirror holds every file DMIRS's two catalogues list, synced weekly, ZIPs kept as ZIPs; a report's listing says what it lacks: complete is false and missing names each file (name, bytes, reason) the mirror does not hold, about 470 files over 325 of 119,000 reports, most of them refused by the department itself (reason unavailable_at_source). Where a report's only PDF is inside one of its ZIPs, that PDF is listed too, with extracted_from naming the ZIP.
  6. 06

    Core scans

    HyLogger-scanned drillholes from every State's core library, interpreted metre by metre.
    holes = list(gd.core_holes(state="WA"))
    hole = gd.core_hole(holes[0]["key"])          # the metre-by-metre mineral log
    metre = gd.core_metre(hole["key"], 120)
    
    Now you have: Hole lists, per-hole mineral logs and tray photos; the same holes open at https://coreflagging.nlp-tlp.org/map?hole=<key>.
  7. 07

    Query the database directly

    When the endpoints are not the shape you need, ask the database. Read-only, with a 30-second statement timeout, up to 5,000 rows a page and 30 queries a minute.
    gd.tables()
    gd.describe("mdhdb_raw.gswa_dh_collar")
    for row in gd.sql("SELECT hole_id, max_depth FROM mdhdb_raw.gswa_dh_collar ORDER BY hole_id", max_rows=5000):
        print(row["hole_id"], row["max_depth"])     # rows as dicts, every page
    # with pandas: GeoData.to_dataframe(gd.sql(...))
    
    Now you have: Rows from any table on the platform, as JSON; give paged queries an ORDER BY so pages do not overlap.
  8. 08

    Map tiles in your own map

    The layers the data map draws are plain tiles; add them to any Mapbox GL or MapLibre map. No token needed.
    map.addSource("drillholes", { type: "vector", tiles: ["https://platform.nlp-tlp.org/geo/api/tiles/drillholes/{z}/{x}/{y}"], minzoom: 5 });
    map.addLayer({ id: "drillholes", type: "circle", source: "drillholes", "source-layer": "drillholes", paint: { "circle-radius": 3 } });
    map.addSource("magnetics", { type: "raster", tiles: ["https://platform.nlp-tlp.org/geo/api/raster/magnetics/{z}/{x}/{y}.png"], tileSize: 256 });
    // vector layers: drillholes, drillholes_density, company_dh_collars, wamex, minedex, tenements, tenements_dead,
    //   faults, worm_mag, worm_grav, hist, geology, regolith, conservation, native_title, pastoral, heritage
    // raster layers: magnetics, gravity (zoom 3–8)
    
    Now you have: The platform's layers inside your own map.
  9. 09

    Use it in QGIS or ArcGIS

    The public layers are also an OGC API – Features service, so a GIS adds them by URL: drillholes and collars (with links to each hole's assays and its CoreFlagging core scan), surface and regional geochemistry, WAMEX report areas, exploration activity, tenements, Minedex, bedrock geology, regolith, faults, worms, conservation reserves, HyLogger scans and reports, and the MineTrace training sites. The rasters come in as XYZ tiles. No token needed; each layer carries its licence, and the faults, bedrock geology, regolith and conservation reserves are non-commercial.
    Service URL   https://platform.nlp-tlp.org/ogc
    All layers    https://geo.nlp-tlp.org/gis   (every layer, its licence, a sample and its catalog page)
    QGIS          Layer > Add Layer > Add WFS / OGC API - Features Layer
                  New > Name: AgenticGeoMate, URL: https://platform.nlp-tlp.org/ogc, Version: OGC API - Features
                  Connect, pick a collection, Add. Zoom in first: features load for the view, 1,000 a page.
    ArcGIS Pro    Insert > Connections > Server > New OGC API Server, URL: https://platform.nlp-tlp.org/ogc
    GDAL / ogr    ogrinfo OAPIF:https://platform.nlp-tlp.org/ogc
                  ogr2ogr -f GPKG drillholes.gpkg OAPIF:https://platform.nlp-tlp.org/ogc gswa_drillholes -spat 121.3 -30.9 121.7 -30.5
    curl          curl "https://platform.nlp-tlp.org/ogc/collections?f=json"
                  curl "https://platform.nlp-tlp.org/ogc/collections/hylogger_core_scans/items?f=json&bbox=121.3,-30.9,121.7,-30.5&limit=100"
    Assays        Collar layers carry assays_url: every interval down that hole, as JSON (paged)
                  curl "https://platform.nlp-tlp.org/geo/api/holes/company/<collar id>/assays/"
    ── Rasters as XYZ tiles ─────────────────────────────────────────────────────────────
    QGIS          Browser panel > XYZ Tiles > right-click > New Connection
                  Name: NTLP magnetics, URL: the template below, Min zoom 3, Max zoom 8, OK
                  Drag the connection onto the map (Web Mercator, EPSG:3857)
    Layer         URL template
    magnetics     https://platform.nlp-tlp.org/geo/api/raster/magnetics/{z}/{x}/{y}.png
    gravity       https://platform.nlp-tlp.org/geo/api/raster/gravity/{z}/{x}/{y}.png
    ArcGIS Pro    Map > Add Data > Data From Path, the same template with {level}/{col}/{row}
                  in place of {z}/{x}/{y}
    ── MineTrace prospectivity surface (one image per metal, not tiles) ─────────────────
    Image         https://platform.nlp-tlp.org/geo/api/surface/Au.png     (Au, Co, Cu, Mn, Ni, REE, Sn, Ta, W; Au_max etc. = upper bound)
    Corners       https://platform.nlp-tlp.org/geo/api/surface/Au/        (west, north, east, south in degrees)
    GDAL          The PNG is in Web Mercator. Georeference it, then open the GeoTIFF in QGIS:
                  gdal_translate -a_srs EPSG:3857 -a_ullr 12567630 -1544447 14363300 -4187029                 /vsicurl/https://platform.nlp-tlp.org/geo/api/surface/Au.png au_prospectivity.tif
                  (corners for Au; for the other metals 12569133 -1542900 14361543 -4184346)
    
    Copy the QGIS, ArcGIS Pro, GDAL Now you have: The platform's layers as live layers in your GIS project, filtered to the area you look at.
  10. 10

    Your own data

    Upload a CSV or GeoJSON, keep it private or publish it, and share it by link. It joins the map and the assistant like any other layer.
    ds = gd.upload_dataset("kalgoorlie_soils.csv", name="Kalgoorlie soils", visibility="public")   # a Read and write token
    print(f"https://geo.nlp-tlp.org/datasets/{ds['id']}")   # the share link
    
    Now you have: A dataset of yours on the platform, with a share link on https://geo.nlp-tlp.org.
  11. 11

    Run a toolbox tool

    Geoscience methods from the UWA / Loop3D group and ours, each run on an area you choose: a stereonet of the structural measurements, the geological topology of the map, and more as they come. Quick tools answer at once; long ones run in the background and email you.
    headers = {"Authorization": "Bearer <token>"}
    tools = requests.get(f"{P}/api/tools/", headers=headers).json()["tools"]   # each with its parameters and paper
    area = {"point": [117.5, -22.0], "radius_km": 10}                         # or {"polygon": [[lon, lat], ...]}
    r = requests.post(f"{P}/tools/api/stereonet/run/", headers=headers,
                      json={"area": area, "params": {"types": ["bedding", "cleavage"], "format": "png"}}).json()
    for o in r["outputs"]:                       # a quick tool: outputs inline (text, or base64 for images)
        print(o["name"], o["format"])
    # a long tool answers 202 with a run id: follow it, then fetch each output
    run = requests.get(f"{P}/tools/api/runs/{r['id']}/", headers=headers).json()
    link = requests.get(f"{P}/tools/api/runs/{r['id']}/outputs/stats.json", headers=headers).json()   # {url} or {dataset_id}
    
    Now you have: A tool's results for your area, with a provenance record of the code, version, parameters and inputs that made them. Map layers it makes go to your data library.
  12. 12

    Agents

    The same data as MCP tools. Add the address to Claude, Cursor or your own agent; sign in with a platform account when the client asks.
    { "mcpServers": { "geo": { "url": "https://geomate.nlp-tlp.org/mcp" } } }
    
    Copy the Claude Desktop / Cursor config Now you have: An agent that can search the documents, query the database and read the drillholes for you.