Back to selected work
FortyGuard Hackathon/Climate Tech · AgriTech

CropHeat AI

Turning hyperlocal climate intelligence into crop-specific heat-risk decisions.

Built for
FortyGuard Hackathon

An explainable hybrid risk engine combining live geospatial temperature intelligence with crop and growth-stage sensitivity.

0–100
Risk output
06
Risk factors
04
Supported crops
FortyGuard
API
Abstract CropHeat AI heat-risk system preview
01 / The problem

Weather data is not the same as crop risk.

Farmers and agronomists can get generic forecasts, but a headline temperature does not answer whether the heat is dangerous for a specific crop at a specific growth stage. CropHeat AI was built to turn field-level climate intelligence into an interpretable risk decision.

02 / The solution

A transparent risk pipeline, not a black box.

CropHeat AI combines FortyGuard's hyperlocal temperature intelligence with sourced crop heat-sensitivity thresholds. The system produces a 0–100 risk score, exposes the factors contributing to that score, and then provides a plain-language advisory.

Hyperlocal data

Temperature, exceedance and persistence heatmaps from FortyGuard.

Six factors

Temperature, exposure, persistence, humidity/wet-bulb, crop sensitivity and growth stage.

Explainable

Transparent weighted scoring with sourced thresholds rather than invented values.

03 / Architecture

From geospatial API to field-level decision.

FortyGuard

Heatmaps + environmental data

FastAPI

Service orchestration

Cache + Guard

SQLite + credit protection

Risk Engine

0–100 explainable score

Dashboard

Map + timeline + advisory

Frontend: Next.js · React · TypeScript
Backend: FastAPI · Python · SQLite
04 / FortyGuard integration

The API stays behind the backend boundary.

FortyGuard calls are isolated behind the backend service layer. The frontend never talks directly to FortyGuard, and the API key stays on the server. Heatmap calls are cached and shared by region, while environmental parameters are sampled selectively to conserve credits.

31.887°C
verified minimum
33.1424°C
verified maximum
2.46 h
mean exposure above 35°C

These values are documented in the project README as personally verified FortyGuard outputs, not fabricated application metrics.

05 / AI advisory

The LLM explains the score — it does not calculate it.

When an Anthropic API key is available, the advisory layer receives the already-computed risk score, severity level, and contributing factors and turns them into plain-language recommendations. If the LLM is unavailable, a deterministic rule-based fallback takes over and is explicitly labeled as such.

06 / Engineering decisions

Built with constraints in mind.

Credit-aware

One shared regional heatmap is preferred over a request per field; caching and a budget guard reduce unnecessary API consumption.

Honest data states

The UI distinguishes LIVE, CACHED, DEMO DATA and SIMULATED instead of presenting synthetic data as live.

Deterministic fallback

Core risk scoring does not depend on an LLM being available, so the product remains usable when advisory generation fails.

Source-backed thresholds

Crop heat-sensitivity thresholds are documented with agronomy references rather than invented for the demo.

07 / Stack

The system stack.

Next.js 15React 19TypeScriptTailwind CSSFastAPIPython 3.12LeafletRechartsSQLiteAnthropic API
08 / Limitations

What is intentionally not claimed yet.

Fixed AOI

The current demo uses a small fixed San Jose, California region sized for the FortyGuard Basic-tier heatmap cap.

Partial simulation

The what-if simulator currently varies temperature; exposure and persistence are not yet wired to a full live recomputation.

LLM smoke test

Live Anthropic calls are implemented but were not smoke-tested with a funded key in the build environment; the rule fallback is confirmed working.

Field join

The current heatmap-to-field mapping uses nearest-centroid matching; polygon area-weighting is a planned improvement.

Explore the build

See the system in action.

Back to all projects