FahrenheitResearch
hermes-weather-plugin
Hermes Agent weather plugin with 13 tools for NWS data, radar, soundings, and ECAPE, backed by Rust for heavy computations.
Repository last updated Apr 5, 2026
Overview
The Hermes Weather Plugin provides a comprehensive set of 13 meteorological tools for the Hermes Agent ecosystem. It offers real-time access to NWS observations, forecasts, alerts, model imagery, NEXRAD radar, soundings, and verified calculations like ECAPE. The plugin is designed for developers and meteorologists who need high-fidelity weather data integrated into an agent workflow.
Architecturally, the plugin is Python-first but offloads computationally intensive tasks—such as radar rendering, model image generation, and thermodynamic calculations—to Rust binaries. On first use, an automated bootstrap process compiles these Rust backends from source, caching them locally. This eliminates the need for manual builds and ensures a streamlined setup.
The plugin supports multiple radar backends (rustdar and nexrad), a wide range of NWP models, and includes tools for severe weather outlooks from the SPC. It is packaged for Hermes plugin autodiscovery via pip and requires only a Rust toolchain for the initial bootstrap.
Highlights
- 13 tools for NWS forecasts, radar, alerts, and calculations
- Rust-backed ECAPE, soundings, and parcel profiles
- Automated bootstrap compiles Rust binaries on first use
- Supports rustdar and nexrad radar backends
- Verified model subsets for soundings and ECAPE
Features
Comprehensive Data Tools
Retrieve current conditions, 7-day forecasts, METAR, global weather via Open-Meteo, and SPC severe outlooks.
Model Imagery and Radar
Generate model field PNGs with wrf-rust and render NEXRAD Level 2 radar images with storm-analysis overlays.
Meteorological Calculations
Compute CAPE/CIN, LCL/LFC/EL, bulk shear, SRH, and ECAPE using Rust-backed metrust and ecape-rs.
Automated Bootstrap
On first use, the plugin compiles required Rust binaries (radar-render, run_case, nexrad-render-cli) into ~/.hermes/weather/bin.
Flexible Configuration
Override binary paths via environment variables like RADAR_RENDER_PATH or ECAPE_RS_RUNNER for prebuilt binaries.
Installation
Commands are reproduced exactly as published by the project maintainers. Always check the upstream repository for the current instructions.
Then start Hermes normally:Hermes should auto-discover the plugin through the Python entry point.
## Runtime model
The plugin is Python-first, but several heavy paths use Rust binaries or Rust-backed Python packages.
- Data tools call NWS, SPC, METAR, and Open-Meteo directly from Python.
- `wx_model_image` uses `rusbie` for model access, tries the newer `wrf-rust` render path first, and falls back to `rustweather` where needed for GRIB model-map rendering.
- `wx_radar_image` and `wx_storm_image` use a radar backend binary.
- `wx_ecape` uses the `ecape-rs` runner.
- `wx_calc` and `wx_sounding` use `metrust` in-process.
If a required Rust binary is missing, the plugin will try to build it on first use into:
- `~/.hermes/weather/bin`
and cache downloaded source/build work under:
- `~/.hermes/weather/src`
## First-use bootstrap
The plugin can bootstrap these binaries automatically:
- `radar-render` from `rustdar`
- `run_case` from `ecape-rs`
- bundled `nexrad-render-cli`
This requires a working Rust toolchain (`cargo`, `rustc`) on the user machine unless they point the plugin at prebuilt binaries.
If you already have binaries installed, set optional overrides:Windows PowerShell:## Tools
### Data
| Tool | What it returns |
|------|-----------------|
| `wx_conditions` | Current observed conditions |
| `wx_forecast` | NWS 7-day or hourly forecast |
| `wx_alerts` | Active NWS alerts |
| `wx_metar` | Raw and decoded METAR |
| `wx_brief` | Conditions + short forecast + alert count |
| `wx_global` | Global weather via Open-Meteo |
| `wx_severe` | SPC categorical outlook + active watches |
### Images
| Tool | What it returns |
|------|-----------------|
| `wx_model_image` | Model field PNG rendered with `wrf-rust` |
| `wx_radar_image` | NEXRAD Level 2 radar image through the configured radar backend |
| `wx_storm_image` | Reflectivity image with storm-analysis overlays and metadata |
### Calculations
| Tool | What it returns |
|------|-----------------|
| `wx_calc` | Rust-backed meteorological calculations through `metrust` |
| `wx_sounding` | Model sounding plus derived parameters |
| `wx_ecape` | ECAPE, NCAPE, CAPE, CIN, LFC, EL, storm motion, optional parcel path |
## Model support
Verified model subsets currently exposed in Hermes:
- `wx_model_image`
- `aigfs`, `gdas`, `gefs`, `gfs`, `graphcast`, `hiresw`, `hrrr`, `hrrrak`, `nam`, `nbm`, `rap`
- `wx_sounding`
- `gdas`, `gfs`, `graphcast`, `hrrr`, `hrrrak`, `rrfs`
- `wx_ecape`
- same verified profile subset as `wx_sounding`
Models outside those sets may exist lower in the backend stack, but they are not exposed until their Hermes extraction path is verified.
## Radar
Hermes keeps a stable radar tool contract and routes it through the configured radar backend.
Current backends:
- `rustdar` (default)
- `nexrad`
Supported radar products:
- both backends: `ref`, `vel`, `sw`, `zdr`, `rho`, `phi`
- `rustdar` only: `srv`, `vil`
## Soundings and ECAPE
`wx_sounding` downloads a verified model pressure-level profile and computes:
- CAPE/CIN: surface-based, mixed-layer, most-unstable
- LCL/LFC/EL
- LI, K-index, Total Totals
- bulk shear and SRH
- precipitable water, lapse rates, freezing level
- standard pressure-level profile output
`wx_ecape` runs the parity-verified `ecape-rs` runner on the same profile.
Defaults:
- `cape_type=most_unstable`
- `storm_motion_type=right_moving`
- `pseudoadiabatic=true`
Supported storm-motion modes:
- `right_moving`
- `left_moving`
- `mean_wind`
- `user_defined`
Set `include_parcel_profile=true` to return the aligned parcel path arrays.
## Packaging notes
This package is intended to be installed with `pip` from GitHub, not copied manually into `~/.hermes/plugins`.
The package exposes the Hermes plugin entry point directly, ships `plugin.yaml`, ships the bundled `nexrad-render-cli` source, installs the bundled skill on first load, and bootstraps Rust binaries on demand.
## StackRequirements
- Python 3.8+
- Rust toolchain (cargo, rustc) for first-use binary builds
- pip install from GitHub
How it's built
The plugin is structured as a Python package with a plugin.yaml for Hermes autodiscovery. Heavy tasks are delegated to Rust binaries: rustdar or nexrad-render-cli for radar, wrf-rust for model images, metrust for in-process calculations, and ecape-rs for ECAPE. The bootstrap process in bootstrap.py checks for required binaries and builds them from source using cargo if missing, caching source under ~/.hermes/weather/src.
Data tools use the requests library to call NWS, SPC, METAR, and Open-Meteo APIs. Model image retrieval uses rusbie for model access and falls back to rustweather for GRIB rendering. The radar backend is configurable via the RADAR_BACKEND environment variable (default rustdar).
The plugin ships with bundled source for nexrad-render-cli under radar_backends/. Python dependencies include numpy, metrust, rusbie, rustweather, and wrf-rust. A Rust toolchain is required only for first-use builds.
Source
This summary was written for Neura Market from the project's own repository. Install commands, identifiers and licence details are reproduced unchanged. The FahrenheitResearch/hermes-weather-plugin repository is the authoritative source and the place to file issues or contribute.
Category: Web & Search