Prototyp · Vorschau: alle Server aus der offiziellen Registry, alle 30 Minuten synchronisiert. Bewertungen und Benutzerkonten folgen in einem späteren Schritt.
PopNx MCPMCP-Server für alle, die KI nutzen · in einfachen Worten erklärt

Umbra open SAR archive

von reesehammerVersion 0.1.4i★ –iComputer oder Cloud
Name in der Registryio.github.reesehammer/umbra-mcp

Installieren

Überblick

Beschreibung vom Entwickler (englisches Original)

Search, preview, and measure Umbra open SAR from any MCP client. Umbra ships no search API.

Die drei Säulen von PopNx MCP

Diese drei werden nie zu einer Punktzahl zusammengefasst: Meinungen, Messungen und Beliebtheit sind verschiedene Dinge.

Was du damit machen kannst

Für diesen Server haben wir noch keine Zusammenfassung in einfacher Sprache geschrieben. Unten stehen die Fakten, die wir aus der Registry gelesen haben.

  • Verbindung: Computer oder Cloud
  • Transport: stdio, Streamable HTTP
  • Kategorie: Suche & KI-Gedächtnis
  • Das musst du eintragen: UMBRA_CANOPY_TOKEN, ANTHROPIC_API_KEY, OPENAI_API_KEY

Installation

Wähle die KI-App, die du nutzt, und kopiere die Einstellungen.

Bevor du installierst

  • Basischecks: 3 von 3 bestanden
  • Läuft auf dem Server des Entwicklers: Was du fragst, läuft über dessen Server.
  • Kann 19 Dinge (Tools) search_catalog, find_repeat_sites, get_item, geocode_place …
  • Das trägst du selbst ein: UMBRA_CANOPY_TOKEN, UMBRA_INDEX_DB, ANTHROPIC_API_KEY, OPENAI_API_KEY

Als geheim markierte Werte sind Schlüssel zu deinem Konto. Gib sie nie weiter und füge sie nie in einen Chat ein.

Du brauchst

  • Läuft in der CloudNichts zu installieren; die Verbindung läuft übers Internet
  • PyPIuv für Python installiert (für den Befehl uvx)

Welche App nutzt du?

Wähle oben deine App. Wir merken sie uns, damit der Button beim nächsten Mal „In … installieren“ anzeigt.

Funktioniert in Claude im Web, auf dem Desktop und auf dem Handy:

  1. Öffne Settings → Connectors
  2. Tippe auf Add custom connector
  3. Füge die Adresse unten ein und tippe auf Add
  4. Wenn eine Anmeldung verlangt wird, melde dich beim Dienst des Entwicklers an
SettingsConnectors1+ Add2https://…3
https://api.umbra-py.space/mcp

Oder führ ihn auf deinem Computer aus

Öffne Claude Desktop → Settings → Developer → Edit Config und füge dies in claude_desktop_config.json ein

{
  "mcpServers": {
    "umbra": {
      "command": "uvx",
      "args": [
        "umbra-py"
      ],
      "env": {
        "UMBRA_CANOPY_TOKEN": "your-value",
        "UMBRA_INDEX_DB": "your-value",
        "ANTHROPIC_API_KEY": "your-value",
        "OPENAI_API_KEY": "your-value"
      }
    }
  }
}

Führe das in deinem Terminal aus

claude mcp add --transport http umbra https://api.umbra-py.space/mcp

Oder führ ihn auf deinem Computer aus

claude mcp add umbra --env UMBRA_CANOPY_TOKEN=your-value --env UMBRA_INDEX_DB=your-value --env ANTHROPIC_API_KEY=your-value --env OPENAI_API_KEY=your-value -- uvx umbra-py

Trag die leeren Werte ein, bevor du ihn startest.

In Cursor öffnen

Oder kopier die Einstellungen selbst

In .cursor/mcp.json in deinem Projekt oder in ~/.cursor/mcp.json einfügen

{
  "mcpServers": {
    "umbra": {
      "url": "https://api.umbra-py.space/mcp"
    }
  }
}

Oder führ ihn auf deinem Computer aus

In Cursor öffnen

Oder kopier die Einstellungen selbst

In .cursor/mcp.json in deinem Projekt oder in ~/.cursor/mcp.json einfügen

{
  "mcpServers": {
    "umbra": {
      "command": "uvx",
      "args": [
        "umbra-py"
      ],
      "env": {
        "UMBRA_CANOPY_TOKEN": "your-value",
        "UMBRA_INDEX_DB": "your-value",
        "ANTHROPIC_API_KEY": "your-value",
        "OPENAI_API_KEY": "your-value"
      }
    }
  }
}

Dein Browser fragt, ob er die App öffnen darf, dann zeigt die App die Einstellungen und bittet dich um Bestätigung. Schlüsselwerte bleiben leer, damit du sie selbst einträgst.

In VS Code öffnen

Oder kopier die Einstellungen selbst

In .vscode/mcp.json in deinem Projekt einfügen

{
  "servers": {
    "umbra": {
      "type": "http",
      "url": "https://api.umbra-py.space/mcp"
    }
  }
}

Oder führ ihn auf deinem Computer aus

In VS Code öffnen

Oder kopier die Einstellungen selbst

In .vscode/mcp.json in deinem Projekt einfügen

{
  "servers": {
    "umbra": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "umbra-py"
      ],
      "env": {
        "UMBRA_CANOPY_TOKEN": "your-value",
        "UMBRA_INDEX_DB": "your-value",
        "ANTHROPIC_API_KEY": "your-value",
        "OPENAI_API_KEY": "your-value"
      }
    }
  }
}

Dein Browser fragt, ob er die App öffnen darf, dann zeigt die App die Einstellungen und bittet dich um Bestätigung. Schlüsselwerte bleiben leer, damit du sie selbst einträgst.

ChatGPT verbindet sich nur mit Servern im Internet:

  1. Öffne ChatGPT im Web → Settings → Connectors (Apps)
  2. Tippe auf Create oder Add (bei manchen Tarifen musst du zuerst Developer mode unter Advanced einschalten)
  3. Füge die Adresse unten ein, gib ihr einen Namen und speichere
  4. Wenn eine Anmeldung verlangt wird, melde dich beim Dienst des Entwicklers an
SettingsConnectors1+ Create2https://…3
https://api.umbra-py.space/mcp

Menünamen können sich je nach Tarif und mit der Zeit leicht unterscheiden.

Deine Auswahl bleibt in einem Cookie auf diesem Gerät; kein Konto nötig.

Werte, die du selbst einträgst

  • UMBRA_CANOPY_TOKEN geheim env
    Canopy API token. Set it and the same search tools query Umbra's authenticated commercial archive instead of the open bucket; leave it unset for the open data, which needs no credentials.
  • UMBRA_INDEX_DB env
    Path to a local catalog index (built with 'umbra index build' or fetched with 'umbra index fetch'). Without one the server walks the public bucket per search, which is correct but slow.
  • ANTHROPIC_API_KEY geheim env
    Optional. With a key, describe_scene and narrate_change call a vision model on the server. Without one they return a reading kit (picture + SAR primer) so the client's own model does the reading. A p…
  • OPENAI_API_KEY geheim env
    Alternative provider for the same two model tools, and the encoder behind find_similar_text.

Diese Einstellungen werden aus dem Registry-Eintrag des Entwicklers erzeugt. Wenn in der README etwas anderes steht, folge der README.

Was er kann

Tool-Namen und -Beschreibungen genau so, wie der Server sie am 7. Nov. 2026 gemeldet hat. Geschrieben hat sie der Entwickler, nicht wir; wir zeigen sie als reinen Text.

  • search_catalog

    Search Umbra's catalog and return compact context cards. Filters (all optional, combine freely): ``bbox`` as ``[min_lon, min_lat, max_lon, max_lat]`` in WGS84 degrees; ``intersects`` as a GeoJSON polygon object (a ``Polygon`` / ``MultiPolygon`` geometry, or a ``Feature`` / ``Feat

  • find_repeat_sites

    Rank the archive's most repeat-imaged sites — where change detection has something to measure. The discovery step *before* every analysis verb. ``change`` / ``timescan`` / ``stack`` / ``pick_change_interval`` / ``narrate_change`` all answer *what* changed at a site, but each assu

  • get_item

    Return the full context card for one item. ``url`` is the JSON URL of an open-data STAC sidecar, a GEC/SICD (or other product) filename such as ``2025-05-17-17-43-46_UMBRA-08_GEC.tif``, or the acquisition stem ``2025-05-17-17-43-46_UMBRA-08``. A filename or stem is resolved throu

  • geocode_place

    Resolve a free-text place name to a bounding box via Nominatim. Returns ``{"bbox": [min_lon, min_lat, max_lon, max_lat], "display_name": ...}`` so the agent can inspect the box before searching, or pass it straight to ``search_catalog``'s ``bbox``.

  • index_stats

    Report on the local catalog index, if one has been built or fetched. Lets a long-running agent decide whether searches will be instant (index present) or pay a live S3 walk, and how stale the snapshot is. ``end`` is the newest acquisition that is not ``datetime_suspect``. ``datet

  • quicklook

    Return a scene's quicklook PNG as an image block. Prefers a baked catalog preview (``preview="auto"``, the default) so a public host can show the radar scene without proxying Umbra COGs. **A baked preview is typically 512 px** (the published weekly sidecar). ``max_size`` applies

  • change_composite

    Composite 2-3 passes of one site into a change image. Pass the STAC URLs of two or three acquisitions of the *same* site in time order. Colors encode change: bright green = signal appeared after the first date, magenta = signal vanished, grey = unchanged. Refuses to mix polarizat

  • timescan

    Summarize a whole time series into one activity image. Pass the STAC URLs of a site's passes; the timescan encodes per-pixel temporal statistics so bright/colored areas are *where activity happened* over the series. Returns the image block plus attribution.

  • stack_stats

    Measure how much a site changed across its passes, as numbers. The quantitative counterpart to ``change_composite`` / ``timescan``: those return a picture of *where* change is, this returns the *how much*. Pass the STAC URLs of a site's passes (2 or more, any order); they are co-

  • stack_provenance

    Check whether a site's passes are one measurement, before measuring them. ``stack_stats`` refuses a selection whose rasters were made by *different* ``umbra convert`` settings — a calibrated pass differenced against an uncalibrated one puts the difference between two conversions

  • pick_change_interval

    Scan a site's whole series and name the two passes worth narrating. The deterministic first half of the "watch a site over time" story, and the step that turns a wall of passes into an answer. Given the STAC URLs of a site's passes (2 or more, any order), it co-registers them int

  • download_asset

    Download one asset of an item to local disk, gated by a size check. SAR products can be multiple GB, so this is a two-step handshake: call it first with ``confirm=False`` (the default) to get the byte size without downloading, then again with ``confirm=True`` to fetch it. On a lo

  • watch_site

    Report only the acquisitions **new** since the last check of this site. SAR's value for monitoring is its cadence, so the natural workflow is *standing*: run the same search each time and act only on what changed. This tool packages that idempotent delta — call it in one turn, co

  • find_similar

    Find archived scenes that **look like** the acquisition at ``url``. This is the one search that lives in the pixels, not the metadata: where ``search_catalog`` filters by date/bbox/task-name, this renders the query item's quicklook, embeds it, and ranks the pre-embedded scene ind

  • find_similar_text

    Find archived scenes matching a plain-language ``query`` over their imagery. Text-to-scene search: embeds ``query`` ("ships at a berth", "a flooded field") and ranks the stored *image* vectors by cosine similarity. It only works when the index was built and this query is embedded

  • describe_scene

    Return a SAR-literate reading of the scene at ``url``. The picture and the metadata card are produced deterministically; a model only interprets them. How that model is reached depends on whether this process holds a vision key: - **No key** (the public community host): this tool

  • narrate_change

    Return a grounded reading of *what changed* between passes. Sibling of :func:`describe_scene`. The composite and the per-block dB grid are produced deterministically; a model only narrates change those numbers support. Pass the STAC URLs in time order; mixed polarizations are ref

  • stamp_description

    Validate a client-produced scene reading and stamp provenance. This is the interpretation boundary for the no-key kit path: you read the picture ``describe_scene`` returned, produce ``{summary, observed_features, confidence, caveats}``, and pass it here. The library checks the sh

  • stamp_narration

    Validate a client-produced change narration and stamp provenance. Sibling of :func:`stamp_description` for the no-key ``narrate_change`` kit. Pass the JSON you produced plus the ``change_stats`` grid from the kit so the stamped object carries the numbers the prose was grounded in

Basischecksi

Wir prüfen Informationen, die jeder sehen kann; den Code haben wir nicht gelesen. Checks, die nicht zutreffen, werden nicht mitgezählt. · Geprüft am 9. Nov. 2026

  • ✓ Bestanden

    Entwickler passt zum Repo

    Der Registry-Name wurde mit dem GitHub-Konto reesehammer bestätigt, dem das Repo gehört

  • … Noch nicht geprüft

    Wird noch gepflegt

    Dieses Repo haben wir noch nicht von GitHub gelesen

  • … Noch nicht geprüft

    Hat eine Lizenz

    Dieses Repo haben wir noch nicht von GitHub gelesen

  • ✓ Bestanden

    Endpunkt antwortet

    Antwort in 128 ms (HTTP 200)

  • – Nicht zutreffend

    Anmeldung mit OAuth

    Keine Anmeldung nötig

  • ✓ Bestanden

    Keine versteckten Anweisungen in Tool-Beschreibungen

    Wir haben 19 Tool-Beschreibungen gelesen und keine versteckten Anweisungen an die KI gefunden

Im Vergleich mit anderen in Suche & KI-Gedächtnisi

  • Mehr Sterne als 0 % der anderen 5730 Server in dieser Kategorie
  • Neuer in der Registry veröffentlicht als 74 % der anderen 5730 Server in dieser Kategorie
  • Basischecks gleich gut wie oder besser als bei 100 % der anderen 5730 Server in dieser Kategorie

Verglichen mit allen aktiven Servern dieser Kategorie in der Registry. Sterne zählen nur, wenn dem Herausgeber das Repo gehört.

Häufige Fragen

Ist Umbra open SAR archive sicher?

Er hat 3 von 3 zutreffenden Basischecks bestanden. Den Code haben wir nicht gelesen. Bevor du einen Schlüssel oder Token hinzufügst, sieh nach, welche Zugriffe der Server verlangt, und nutze einen Schlüssel, der nur die Berechtigungen hat, die du brauchst.

Welche Schlüssel oder Codes braucht er?

Das musst du eintragen: UMBRA_CANOPY_TOKEN, ANTHROPIC_API_KEY, OPENAI_API_KEY

Läuft er auf meinem Computer oder in der Cloud?

Beides geht: Installiere ihn auf deinem Computer oder verbinde dich mit der Cloud-Version.

Wird er noch gepflegt?

Das GitHub-Repo wurde zuletzt – geändert, und die neueste Version (0.1.4) kam vor 13 Tagen in die Registry.

Welche Apps können ihn nutzen?

Apps, die MCP unterstützen, etwa Claude Desktop, Claude Code, Cursor und VS Code. Er verbindet sich per URL, also funktionieren auch Apps, die Remote-MCP-Server akzeptieren, zum Beispiel ChatGPT im Entwicklermodus.

Was kann ich stattdessen nutzen?

In derselben Kategorie: Context7, Codebase Memory, Exa

Alternativen

Server derselben Kategorie von anderen Entwicklern, sortiert nach Sternen.

So liest du eine Karte:↓ Downloads pro Wochei★ GitHub-SterneiDrei Säulen: Bewertungen · Checks · NutzungiAktualisiert = neueste Version in der Registry veröffentlichti

Context7

Up-to-date docs for AI agents

von upstashWeit verbreitet↓ 972.664/Wo.★ 64.224Aktualisiert vorgestern

Computer oder Cloud

Codebase Memory

Codebase knowledge graph for AI agents — 162 languages, sub-ms queries, 99% fewer tokens.

von DeusDataWeit verbreitet↓ 17.962/Wo.★ 48.148Aktualisiert vor 22 Tagen

Läuft auf deinem Computer

Exa

Connect AI agents to Exa for web search, content fetching, and multi-step research.

von exa-labsWeit verbreitet★ 5213Aktualisiert vor 2 Monaten

Läuft in der Cloud✓ exa.ai

README vom Entwickler

README öffnen

Unverändert aus dem Repo des Entwicklers übernommen. PopNx MCP hat den Inhalt weder geprüft noch empfiehlt es ihn. HTML, Bilder und Skripte wurden entfernt. Links führen von dieser Website weg.

umbra-py

Search, preview, load, and convert [Umbra](https://umbra.space/open-data/) open SAR data.

Umbra publishes 16–25 cm SAR as CC BY 4.0 open data, but no search API — only a 17+ TB S3 bucket and a static STAC tree. umbra-py is that layer: search, preview, download, and analysis-ready arrays without the usual 500 lines of glue. A community STAC API (umbra serve) and MCP server sit on the same host, so pystac-client and Claude can query the archive with nothing installed.

📖 Docs: umbra-py.space · Showcase: browse the archive in the browser (no install) · Already listing the bucket? Replace your crawler (HTTP, pystac-client, or DuckDB over the weekly Parquet)

Status: v0.1.4. Discovery, download, xarray loading,

SICD → geocoded COG, change/timescan composites, chips, a STAC API

(umbra serve, with a community host), and an MCP server all ship. This is

not an InSAR toolbox (phase is not preserved through convert). Not

affiliated with Umbra Lab, Inc.

Hosted API (api.umbra-py.space): best-effort 99% monthly uptime, no SLA, 120 requests/minute, page size 10,000. Limits, CORS, and the parquet fallback.

Install

pip install umbra-py              # core: search + download + metadata

pip install "umbra-py[load]" # + xarray / rasterio pip install "umbra-py[viz]" # + quicklooks, maps, galleries pip install "umbra-py[convert]" # + SICD → geocoded COG pip install "umbra-py[all]" # convert + load + viz + export

Python 3.10+. Other extras (dask, serve, mcp, ai, langchain, llamaindex) are listed in the install guide.

Five minutes to a scene

Fetch the weekly catalog snapshot, then search and preview offline. A live walk of the bucket (umbra search without --local) works but is slow.

pip install "umbra-py[viz,load]"

umbra index fetch umbra search --local --area Centerfield --product GEC --limit 3 umbra gallery --local --area Centerfield --limit 6 --out gallery.html --db

from umbra_py import CatalogIndex, to_xarray

with CatalogIndex.from_release() as index: item = next(iter(index.search(area="Centerfield", product_types=["GEC"], limit=1)))

Stream a downsampled window over HTTP — no multi-GB download. Needs [load].

da = to_xarray(item, max_size=1024, db=True) print(item.summary())

If the snapshot is missing, the same search against the live bucket is UmbraCatalog().search(...) / umbra search --area Centerfield.

What you can do

More detail, options, and caveats live in the docs.

Search by bbox, place name, polygon, or Umbra task (area=). --local reads the snapshot; omit it to walk S3.

from umbra_py import UmbraCatalog

for item in UmbraCatalog().search(area="Centerfield", product_types=["GEC"], limit=5): print(item.summary())

Preview without downloading the scene: umbra gallery, umbra quicklook --out scene.png --db, umbra view (full-res tiles), or umbra change --area Centerfield --out change.png.

Load a geocoded GEC into xarray or a GeoTIFF (to_xarray, to_geotiff, to_stack). Needs [load].

Convert a SICD to a north-up amplitude COG (sicd_to_geocoded_cog, umbra convert) — phase is discarded. Needs [convert]. Open products generally have no radiometric metadata, so --calibrate / --noise-model measured refuse rather than invent numbers. See limitations and the complex-product handoff.

Chip scenes into georeferenced ML tiles for SR / ATR-style benchmarks from open Umbra GEC/SICD: umbra chips --area Centerfield --out chips/. See the ISR training-set cookbook and Used in research.

Drive it from an agent. Copy-paste recipes for Claude Desktop and Claude Code: Connect Claude (MCP).

Zero-install remote MCP (no uvx):

# Claude Code

claude mcp add --transport http umbra https://api.umbra-py.space/mcp --scope user

{

"mcpServers": { "umbra": { "url": "https://api.umbra-py.space/mcp" } } }

Paste that JSON into Claude Desktop (claude_desktop_config.json). Claude Code needs "type": "http" on the same URL — see the MCP page.

Local stdio (server on your machine):

uvx --from 'umbra-py[mcp]' umbra-mcp
{

"mcpServers": { "umbra": { "command": "uvx", "args": ["--from", "umbra-py[mcp]", "umbra-mcp"] } } }

That command is published to the MCP registry as io.github.reesehammer/umbra-mcp. STAC for pystac-client / QGIS is https://api.umbra-py.space/ (not /mcp). docker compose -f deploy/docker-compose.yml up is the one-command self-host.

What the data looks like

AssetWhat it isUse it for
GECGeocoded cloud-optimized GeoTIFFMap-ready imagery. Start here.
CSIColor sub-aperture GeoTIFFQuick-look RGB, not a measurement
SIDDGeocoded detected image (NITF)Detected imagery in a standard format
SICDComplex slant-plane image (NITF). Open archive: RGAZIM/PFA.Phase-preserving downstream. Download; do not convert.
CPHDCompensated phase historyCustom formation *outside* umbra-py (download; do not convert). Not an image.

umbra-py downloads SICD/CPHD. umbra convert geocodes a SICD to amplitude and discards phase. It does not form interferograms or compute coherence. For a processor that needs the complex pixels, see Complex products (SICD/CPHD).

Data license & attribution

Umbra's imagery is CC BY 4.0. If you use or redistribute the data or derived products you must attribute Umbra. The copyright notice Umbra's terms require is quoted under Citing umbra-py. umbra-py also stamps this shorter line on its own outputs:

Contains Umbra open data, licensed under CC BY 4.0.

umbra-py itself is Apache 2.0 (LICENSE). The two licenses are independent and compatible.

Citing umbra-py

Cite all versions with the concept DOI 10.5281/zenodo.23676715 (Zenodo's Cite all versions? value). It resolves to the latest archived release. The v0.1.4 version DOI is 10.5281/zenodo.23676716. Machine-readable metadata lives in CITATION.cff (GitHub's Cite this repository button) and .zenodo.json (what Zenodo archives).

@software{hammerstrom2026umbrapy,

author = {Hammerstrom, Reese}, title = {umbra-py}, year = {2026}, version = {0.1.4}, doi = {10.5281/zenodo.23676715}, url = {https://github.com/reesehammer/umbra-py}, license = {Apache-2.0} }

Imagery is © Umbra Space, licensed CC BY 4.0. Umbra's terms require this copyright notice on or adjacent to adapted materials, with [YEAR] the year the image was first created:

SAR-derived data © [YEAR] Umbra Lab, Inc.

Also credit Umbra, link the license, and say if you changed the data. The open-data program is umbra.space/open-data.

Repo layout

PathRole
src/umbra_py/Package source
docs/Published user manual (mkdocs → umbra-py.space)
docs/schemas/Public JSON contracts (also in the wheel)
.github/TODO.mdMaintainer ledger of scoped-out follow-ups
deploy/Dockerfiles, docker-compose.yml, entrypoint
railway.tomlRailway Config-as-Code (dockerfilePath → deploy/Dockerfile.mcp)

Self-host: docker compose -f deploy/docker-compose.yml up (build context stays the repo root). More in docs/README.md and the deploy guide.

Community

  • Contributing · Code of Conduct · Security
  • Example notebooks · Limitations

Acknowledgements

Built on the SAR open-source community, including sarpy and Umbra's open data program. Not affiliated with or endorsed by Umbra Lab, Inc.

PopNx fragen