DEV Community: Kourtney Lee

Peak Season: an open-source AI that tells you where the leaves are at their peak, anywhere in the world

Kourtney Lee — Mon, 12 Oct 2026 03:42:48 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Every October I ask the same question: are the maples in High Park at their best yet, or am I a week early? I'm not the only one. Someone in Kyoto asks it about momiji (紅葉), someone in Seoul about danpung (단풍), and in a few months someone in Sydney or Taipei will ask it about cherry blossoms. The answer usually exists. It's just scattered across yesterday's photos on the internet.

Peak Season answers it for wherever you are. Open the page, and it shows:

the plant of the moment for your area: autumn leaves now, cherry blossoms in spring. It's picked from where recent reports are coming in, so it works in both hemispheres without a calendar;
a short list of places near you, Peak first, then by distance. Each place has a stage badge (Green / Turning / Peak / Past peak), how many recent reports back it up and how fresh they are, and one photo with its photographer's credit and licence;
Directions buttons that open Google Maps, Apple Maps or OpenStreetMap on your phone.

There's no feed, account or infinite scroll. I wanted the screen to be the shortest part of the outing: you decide, tap Directions, and go outside.

It's for anyone who loves an autumn walk but doesn't want to drive an hour to find bare branches. And it's built to keep running, for free, long after this challenge.

Demo

Live: https://peak-season-dvl.pages.dev/

It asks for your location. If you'd rather not share it, pick a city. To look at other places, add coordinates to the URL:

The data refreshes every 12 hours, and "Last updated" at the bottom shows how fresh it is. It's early October, so most of the world is still green or just starting to turn, and that's what the site shows. Where there isn't enough evidence, it says "Not enough reports".

Code

klee1611 / peak-season

Where nature is at its peak near you, right now. Gemma on a free GitHub Actions runner judges autumn leaves and cherry blossoms from iNaturalist photos. $0/month.

Peak Season

Where nature is at its peak near you, right now. Autumn leaves, cherry blossoms, and more anywhere in the world.

Peak Season collects recent public nature photos (iNaturalist) and web reports (SerpApi, for famous spots). An open-weight model, Gemma, runs on a free GitHub Actions runner and judges how far along each seasonal moment is in each photo. The site then tells you, for wherever you are, which places nearby are at their best, how fresh the evidence is, and gives you one-tap directions in your own map app. Decide, tap Directions, go outside.

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 1: "Touch Grass".

Live site: https://peak-season-dvl.pages.dev/
Runs at $0/month: a static site plus a scheduled GitHub Actions job. No servers, no database, no paid APIs required.

How it works

 every 12 h, GitHub Actions (CPU only, free for public repos)
 iNaturalist (global) ─┐
 SerpApi

…

View on GitHub

MIT licensed. The pipeline is Python 3.12 and the site is vanilla JavaScript, with no framework, map library or third-party scripts. There are 110 tests.

How I Built It

The open-source AI at the core is Gemma (gemma4:e2b-it-qat, a small multimodal Gemma), served by Ollama on a free GitHub Actions runner. It runs on the runner's CPU and costs nothing.

GitHub Actions, every 12 hours (free CPU runner)

     iNaturalist photos              SerpApi web snippets
        (worldwide)                  (famous spots only)
             │                                │
             └───────────────┬────────────────┘
                             ▼
            Gemma via Ollama judges the stage
             (every answer cached in SQLite)
                             │
                             ▼
         Group into ~5 km cells, weighted average
                             │
                             ▼
       Small JSON files, one per region: git commit
                             │
                             ▼
          Cloudflare Pages serves the static site;
           your browser loads only your region

1. Collect. The workflow pulls recent iNaturalist observations of each plant worldwide. It keeps only photos whose Creative Commons licence allows showing them. One run finds about 5,600 maple observations in 3,100 places.

2. Gemma looks at the photos. For each photo, Gemma answers in strict JSON: is this really a maple, and is it green, turning, at peak or past peak? The answer is checked against the plant's list of stages. Invalid output gets one retry, then it's marked unclassified. Photos of just a trunk or a single fallen leaf are rejected, because they say nothing about the tree.

3. Gemma reads the web, in the local language. iNaturalist is used mostly by naturalists in North America and Europe. Millions of people visit Arashiyama or Seoraksan in autumn, but those places barely appear there. So for world-famous spots that are in season nearby but have few reports, the pipeline searches Google through SerpApi, in the spot's own language, for the past week only:

"嵐山" 紅葉 見頃                         Arashiyama, autumn leaves, best viewing     hl=ja gl=jp
"parc de la Gatineau" couleurs automne                                             hl=fr gl=ca
"fall colours" "High Park"                                                         hl=en gl=ca

Gemma then reads the result snippets and extracts a stage. It understands phrases like 見頃 (at its best), 色づき始め (starting to turn) or 단풍 절정 (peak). The site links to the sources and doesn't download their images.

4. Combine. Reports are grouped into cells about 5 km across and averaged. Fresh, confident reports count more (confidence × weight × e^(−age / 3 days)), and a web snippet counts 0.6 of a photo. A place with fewer than two reports shows "Not enough reports" instead of a stage.

5. Publish static files. The workflow commits small JSON files, one per region of about 1,250 km (about 240 KB for the whole world), and Cloudflare Pages redeploys. Your browser downloads only your region and its neighbours, and works out distances itself. Visitors never trigger an API or model call, so traffic costs nothing, however much there is.

A free CPU is slow, so the pipeline has a budget

On the runner's CPU, Gemma takes about 44 seconds per photo (17 s on my laptop's GPU). That's about 110 photos per run, against thousands of new ones. So each run spends its time carefully: at most 3 photos per place, famous spots first, then the busiest places, newest photos first. It stops at a fixed time so it always finishes publishing. Every answer is cached, so the next run picks up where the last one stopped.

SerpApi has its own guardrails. Before searching, the pipeline asks SerpApi's account endpoint how many searches are left (that check is free). It keeps a reserve, caps searches per run, and never repeats a search within 48 hours. If it can't check the account, it makes zero searches.

The first live SerpApi run found a bug: photos ran first and used up the time, so Gemma read only 13 of the 32 snippets I'd paid searches for. Now, when SerpApi is on, photo work stops 20 minutes early so every paid search gets read.

Don't trust the model: test it first

A plant only appears on the site after its prompt agrees with iNaturalist's community annotations (people tagging a photo "Green Leaves", "Colored Leaves", "Flowers"...) on at least 20 photos, at 70% or better.

My first maple prompt failed at 62%. Gemma called green leaves "turning" whenever sunlight hit them, when the canopy was lit from behind, or when leaves had cream-coloured edges. I also found a bug in my own test: one observation can be tagged both "Green Leaves" and "Colored Leaves" (a half-turned tree), and I was counting a correct answer as wrong. After fixing both, maple passed at 81%, and again at 81% on 26 older photos the prompt had never seen. Cherry blossoms passed at 92%, with one caveat I'd rather say out loud: none of the sample photos showed buds only, so "buds vs. bloom" hasn't really been tested yet.

Two more rules. iNaturalist's "Colored Leaves" tag marks a place as in season but never sets a stage, because it covers everything from the first red leaf to bare branches. And nothing in the code knows what a maple is. Each plant is a YAML file and a prompt, so cherry blossoms went live in the southern hemisphere with no code changes.

Why Does Open Innovation Matter?

Without an open model, this project couldn't run for free.

Peak Season looks at hundreds of photos a day. With a closed vision API, that would be a monthly bill that grows with the world. With Gemma on a free runner it's $0 a month, however many people visit, so it can keep running after the hackathon instead of shutting down when the credits run out.

The same open model reads a photo from Toronto and a Japanese news snippet about Arashiyama. I didn't have to pay extra to make it work in more than one language.

People's photos only go to a model running on the project's own runner. They're never sent to a third-party AI service, and never stored or rehosted.

Nothing is locked in. The model is called through the OpenAI-compatible protocol, so moving to a bigger Gemma, or to a hosted Gemma when the CPU isn't enough, takes two repository secrets and no code change. The site is plain files that could move to any static host tomorrow.

Anyone can check the work. The prompts, the validation script, its results and the data are all public. If you think Gemma is wrong about your local park, you can see why, and fix it.

And a new plant is a pull request. Plum blossoms, tulips, lavender or ginkgo each need one YAML file and one prompt, which would make a nice first Hacktoberfest contribution.

The same pipeline tells someone in Toronto when to see maples and someone in Sydney when to see cherry blossoms, and I'd like it to stay open for anyone to use or extend.

Prize Categories

Best Use of Gemma: Gemma runs self-hosted on a free CPU runner, judges photos, and reads web snippets in Japanese, Korean, Chinese, French and English, with a public, repeatable test against iNaturalist annotations.
Best Use of SerpApi: budgeted searches in the local language for famous spots that iNaturalist misses, with the budget read live from SerpApi's account endpoint and every response cached.

Thanks for reading. Now close the tab and go outside. 🍁

Maple Route: A Multi-Agent AI That Checks Whether Canadian Immigration Rules You Heard Are Still True

Kourtney Lee — Mon, 05 Oct 2026 04:29:14 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

Note: Maple Route covers only a few official pages, so it can't answer every immigration question and may leave out rules that apply to you. It's a reference for spotting possible options and policy changes, not legal advice. For your situation, please talk to a licensed immigration consultant (RCIC) or a lawyer.

What I Built

Maple Route is a multi-agent AI system that answers questions about a small set of Canadian immigration topics, using only official pages stored in a Sanity Knowledge Base:

Express Entry points (CRS criteria)
open work permits for spouses and family members
post-graduation work permit eligibility
2026 changes to the Ontario Immigrant Nominee Program
a few related canada.ca pages, such as the Global Talent Stream

Four AI agents work on each question: one understands your situation, one reads the relevant Knowledge Base entries, one writes the answer, and one checks every statement against its source. A final code step removes anything the sources don't support. Maple Route tells you which options might apply, and flags a rule you mention if it has changed. If a question is outside these pages, it says so instead of guessing.

I built it with tech workers in mind, because the rules they rely on change often. Express Entry stopped giving points for job offers in March 2025. Spousal open work permits were narrowed. Post-graduation work permit rules have changed several times. But blog posts, forum threads and AI chatbots keep repeating the old versions. People planning a move, often reading in their second language, can't easily tell which version is current, and getting it wrong can cost them months.

You describe your situation in plain words: "I'm a software developer in Toronto with a job offer", or "I read that a job offer gives me 50 extra Express Entry points". Maple Route then:

answers only from a Sanity Knowledge Base of official pages, never from the model's own memory;
puts a citation on every statement, and removes any statement it can't back with a source;
checks the rules you mention, and shows a Changed callout when one is out of date: what you heard, what the current rule says, and the official source;
says plainly when its sources don't cover your question.

Here's the difference it makes. I asked the same model the same question with and without the Knowledge Base:

Question: I read that a job offer gives me 50 or 200 extra points in Express Entry. Is that still true?

Same model, no Knowledge Base: "Yes — having a valid job offer can still add points in the Express Entry system… NOC 00: 200 points… other skilled: 50 points."

Maple Route: "Job offer points are no longer added to the Comprehensive Ranking System score for any Express Entry candidate. [1]"

⚠ Changed. Before: A job offer grants 50 or 200 extra points in Express Entry. Now: As of March 25, 2025, job offer points have been removed from the CRS for all current and future candidates. — [1] Express Entry: Comprehensive Ranking System (CRS) criteria, Canada.ca

The full side-by-side for all test questions is in eval/results.md.

Demo

Live: https://maple-route.vercel.app

Try one of these:

I read that a job offer gives me 50 or 200 extra points in Express Entry. Is that still true? (shows the Changed callout)
Does my spouse get an open work permit if I come to Canada on a work permit?
I graduated from a Canadian college program two years ago. Can I still get a post-graduation work permit?
Can I get a work permit in Australia? (it says this is outside its sources instead of guessing)

It's a free project running on free tiers, so there's a daily answer limit shown on the page. Repeated questions are served from a cache.

Code

klee1611 / maple-route

Multi-agent assistant for Canadian work permit and PR rules, grounded in a Sanity Knowledge Base, with citations and changed-rule detection.

Maple Route

A multi-agent AI system that answers questions about a small set of Canadian immigration topics, using only official pages stored in a Sanity Knowledge Base:

Express Entry points (CRS criteria)
open work permits for spouses and family members
post-graduation work permit eligibility
2026 changes to the Ontario Immigrant Nominee Program
a few related canada.ca pages, such as the Global Talent Stream

Four AI agents work on each question, and a final code step removes anything the sources don't support. Every claim has a citation, rules the user mentions are flagged if they have changed, and questions outside these pages get a "not covered" answer. Built with tech workers in mind.

Live: https://maple-route.vercel.app · Demo video: https://youtu.be/1-cmFlTunG8 · Write-up: DEV.to

Maple.Route.-.demo.GitHub.mp4

Maple Route is free to use. If it helped you, you can support it here:

Information, not legal advice. Not affiliated with the Government of Canada.

Scope:

…

View on GitHub

Python (FastAPI, LangGraph) with Groq models, and a Next.js frontend, deployed as one Vercel project.

How I Used Sanity

The Sanity Knowledge Base is the core of Maple Route. It is the agents' only source of policy facts.

What I pointed Sanity Context at. I kept the Knowledge Base small and focused. It has five website sources, all official pages:

Source	Topic
canada.ca: Express Entry CRS criteria	Express Entry points
canada.ca: Open work permits for family members	Spouse and family work permits
canada.ca: Post-graduation work permit eligibility	Post-graduation work permits
canada.ca: Immigration, Refugees and Citizenship	IRCC home page and a few related pages, such as the Global Talent Stream (3 documents)
ontario.ca: 2026 OINP updates	Ontario Immigrant Nominee Program changes

That's deliberately narrow: enough to show the approach on rules that changed recently, not a complete guide to Canadian immigration. Questions outside these pages get "I can't answer this from my sources" instead of a guess.

Because they're website sources, the Knowledge Base can re-check the live pages for changes, so answers follow the current version of each page without a redeploy.

The best surprise: the Knowledge Base builds its own change history. From these pages, the build produced a policy timeline entry with "What is now outdated" and "What is currently active" sections and effective dates. I had planned to hand-model rule changes as separate documents. I didn't need to, because the Knowledge Base did it from the sources.

Which Sanity Context tools the agent uses. The backend connects to a Context MCP endpoint in Knowledge Base mode (read-only, with a read token) and uses two tools:

initial_context: the outline of the Knowledge Base's entries. The policy agent uses it to choose which 1–3 entries a question needs, plus the change timeline.
knowledge_base_read: the full text of those entries, each ending with a numbered list of the sources it was built from.

The endpoint serves only the Knowledge Base, so nothing else competes with it.

What the agents do with the content. The run is a LangGraph graph of five steps:

orchestrator → policy_agent → synthesizer → verifier → finalize
                     ▲                          │
                     └── recheck (max 2 times) ─┘

Orchestrator: pulls out your situation and any rule you state as fact ("I read that…").
Policy agent: reads the chosen entries with knowledge_base_read and extracts findings. Each finding cites a reference number from the entry's Sources list.
Synthesizer: writes the answer using only those findings.
Verifier: checks every statement, and every rule you mentioned, against the entry text it cites, including the change timeline. Each one is marked supported, unsupported, outdated or conflict. If something is outdated or unsupported, the draft goes back to the policy agent ("Found a rule that changed — rechecking").
Finalize (plain code, no LLM): removes unsupported statements and builds the Changed callouts with both sources.

Two design choices kept the answers honest:

The model never writes URLs. It cites a reference number, and code looks up the title, URL and date in the entry's own Sources list. A citation that isn't in the entry is dropped, so a made-up source can't reach the user.
Retrieved content is data, not instructions. Every prompt says so, and only statements backed by a Knowledge Base source survive the final step.

The page streams each agent's progress as it happens, shows a "✓ Checked" mark next to each statement, and lists the sources under the answer, so the Knowledge Base's provenance stays visible to the user.

Sanity Project Details

Sanity project ID: xi8sftv7
Knowledge Base: the Policy Knowledge Base, served through Sanity Context MCP at https://api.sanity.io/v1/context/organizations/omqxvfyjj/mcp/maple-route-policy

Maple Route gives information from official sources, not legal advice. For your specific case, talk to a licensed immigration consultant (RCIC) or lawyer. It's an independent project, not affiliated with the Government of Canada.

Snap Your Fridge, Get a Recipe: Building PantryLens with Gemma 4

Kourtney Lee — Sun, 24 May 2026 07:45:21 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

PantryLens — a free, installable Progressive Web App that turns a photo of your fridge or pantry into a complete, ready-to-cook recipe in seconds.

The idea is simple: food waste is a real problem, and one of its biggest causes is not knowing what to cook with what you already have. PantryLens removes that friction entirely. You open the app, snap up to 3 photos of your ingredients, tap Generate Recipe, and watch a full recipe stream to your screen — live, token by token — before you even put your phone down.

Key features:

📷 Camera capture, file upload, or drag-and-drop (up to 3 images)
⚡ Recipe streams live to the screen as Gemma 4 generates it
📱 Installable PWA — works on iOS and Android home screens, no App Store needed
🔒 No account, no login, no data stored — your photos never leave the request cycle
🆓 Completely free to use

Demo

Live app: https://pantry-lens-one.vercel.app

Install on your mobile home screen: Open the web app in the browser and use the built-in "Add to Home Screen" feature

Code

klee1611 / PantryLens

Turn your fridge photos into recipes — PWA powered by Google Gemma 4 via OpenRouter. Built for the Google Gemma 4 Hackathon on DEV.

PantryLens

Snap a photo of your fridge or pantry — get a recipe in seconds.

PantryLens is a progressive web app (PWA) that uses AI vision (Google Gemma 4) to identify ingredients from photos and stream a complete recipe directly to the screen, token by token.

How it works

Capture — take a photo with your camera, upload from your gallery, or drag and drop (up to 3 images)
Compress — the browser Canvas API resizes each image client-side to ≤1024 px before upload
Analyze — a Next.js Edge Function proxies the images to OpenRouter's vision model
Stream — the recipe streams back token-by-token, rendered progressively as Markdown

Demo

demo.mp4

Pin PWA to mobile home screen

Tech stack

Layer	Technology
Framework	Next.js 16 (App Router, Edge Runtime)
UI	React 19, Tailwind CSS, react-markdown
AI	OpenRouter — `google/gemma-4-26b-a4b-it`
Rate limiting	Upstash Redis (sliding window, 5 req/IP/hour)
Testing	Jest 29, Testing Library,

…

View on GitHub

The project is fully open source under the MIT license. The stack:

Layer	Technology
Framework	Next.js 16 (App Router, Edge Runtime)
UI	React 19, Tailwind CSS, react-markdown
AI model	Gemma 4 via OpenRouter
Rate limiting	Upstash Redis (sliding window, 5 req/IP/hour)
Deploy	Vercel

How I Used Gemma 4

The model: google/gemma-4-26b-a4b-it

I used Gemma 4 26B A4B — the 26B total parameter Mixture-of-Experts model with 4B active parameters per forward pass, instruction-tuned. I accessed it through OpenRouter using the model ID google/gemma-4-26b-a4b-it to meet the following requirements:

Vision capability — PantryLens is fundamentally a vision task. The model needs to look at a photo of a messy fridge shelf and accurately identify eggs, half-used condiments, wilting vegetables, and leftover containers. Gemma 4's multimodal architecture handles this reliably, even for cluttered or poorly lit photos.
Instruction following — generating a well-structured recipe means strictly following a Markdown template with headings, bullet lists, and numbered steps. The instruction-tuned variant follows these formatting constraints consistently, which is critical for the progressive rendering to look correct as it streams.
Speed vs. quality balance — the MoE architecture means the model activates only 4B parameters per token while drawing on the full 26B parameter knowledge base. In practice, this produces recipe quality close to the denser models at latency that works well for streaming UX.

Compare different models of Gemma 4 for this use case:

Why reject the Edge 2B (E2B) model? While E2B is phenomenal for air-gapped, localized execution, its compressed parameter count lacks the deep "world knowledge" required for cooking.
Why reject the Full Precision 31B model? Uncompressed FP16/BF16 models demand massive VRAM clusters. In a serverless architecture, this translates to an unacceptable Time-to-First-Token (TTFT), virtually guaranteeing HTTP 504 gateway timeouts before the proxy can return data.
The Optimal Route (26B-A4B): Utilizing the 4-bit Activation-Aware Quantized (A4B) variant delivered the exact sweet spot. It retains near-frontier reasoning capabilities for complex visual extraction, but the 4-bit memory footprint drastically accelerates upstream inference, enabling ultra-low latency token generation.

The architecture: an opaque streaming proxy

The most interesting engineering decision was how the model is integrated. The frontend never touches the API key or sees the system prompt. Here's the full flow:

The Next.js API route runs on the Vercel Function using Edge Runtime for quick cold starts and low geographical latency. The 300-second timeout limit is acceptable since the response is unlikely to keep streaming for that long.

Client-side image compression was another non-obvious requirement. Vercel Function has a payload limit of 4.5 MB. Raw iPhone photos are 4–12 MB each — three of them would blow the limit before a single byte of AI processing begins. The solution: compress each image on-device using the browser's Canvas API (resize to ≤1024px, JPEG at 75% quality) before the upload. A 10 MB photo becomes ~150 KB. This happens invisibly in under a second on any modern device, including older iPhones.

Server-Sent Events (SSE)

Waiting for a dense 26-billion parameter model to synchronously generate a complex, structured Markdown response will take anywhere from 10 to 25 seconds. In a standard Vercel serverless environment, this guarantees an HTTP 504 Gateway Timeout before the response ever completes.

To bypass this, we must establish a zero-buffer data pipe. I decided to go with SSE (Server-Sent Events):

The Handshake: The PWA makes a standard HTTPS POST request to the Vercel Edge proxy.
The Proxy Stream: The Edge proxy securely forwards the payload to OpenRouter (stream: true).
Token-by-Token Egress: As the Gemma 4 model yields individual tokens (often representing single characters or words), the Edge function immediately pipes those chunks back to the client over the still-open HTTP connection via the text/event-stream protocol.

This provides an immediate Time-to-First-Token (TTFT). The Vercel function never buffers the full response in memory, completely bypassing the gateway timeout constraint. On the frontend, the PWA intercepts these SSE chunks via the native ReadableStream API, feeding them directly into react-markdown for a live, progressive render.

The system prompt

Getting Gemma 4 to output clean, consistently structured Markdown for streaming required careful prompt engineering. The key lessons:

Explicit blank-line rules: without being told explicitly that every ### heading must have a blank line before and after it, the model occasionally merged headings and body text onto the same line, which broke the Markdown renderer.
Numbered list enforcement: instructions would sometimes collapse into a single paragraph unless the prompt explicitly stated "each step must be on its own line — never merge steps into a paragraph."
Pantry staples assumption: by default the model sometimes refused to generate a recipe if it couldn't see salt or oil in the photo. Telling it to assume common pantry staples are always on hand (even if not visible) fixed this.
Single-response constraint: without explicit instruction to never ask follow-up questions, the model occasionally responded with clarifying questions ("Are these all the ingredients?") instead of generating the recipe immediately.

The final prompt includes a section of explicit formatting rules before the template:

FORMATTING RULES — follow exactly:

The recipe title uses ## (two hashes). It must be alone on its own line.
Each section header uses ### (three hashes). It must be alone on its own line.
Every heading must have one blank line before it AND one blank line after it.
The instructions section is a numbered list. Each step is on its own line. Never merge steps into a paragraph.

Application Design Wrapping Up

The architecture here — Vercel Function as opaque AI proxy, client-side compression, streaming passthrough — is a reusable pattern for any vision AI application that needs to:

Keep API credentials out of the frontend
Handle large image payloads within serverless limits
Deliver a live "typing" UX without server timeouts via SSE

PantryLens is the simplest possible version of this pattern, which makes the code easy to read and adapt.

AuroraPath - Chasing the northern lights | Earth Day Weekend Challenge

Kourtney Lee — Mon, 20 Apr 2026 03:51:28 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

AuroraPath — a real-time, carbon-optimized dashboard for sustainable aurora borealis viewing. 🌌🌿

Aurora hunting typically means driving long distances into rural darkness alone at night — one of the least carbon-efficient leisure activities imaginable. AuroraPath flips that script: it combines live NOAA space weather data with an Auth0-managed AI agent that generates travel recommendations prioritizing trains, buses, and carpooling over solo drives.

Auth0 is the backbone of AuroraPath's trust model. It enforces two distinct identity layers:

Human identity (User Auth) — Only authenticated users can invoke the AI. This prevents anonymous abuse of the Gemini API budget and ensures every recommendation is tied to a real account.
Machine identity (M2M Agent Auth) — The Gemini AI orchestrator runs under its own dedicated Auth0 Machine-to-Machine credential, completely separate from user auth. The AI agent has a traceable, revocable identity — if the M2M token is rotated or revoked, the AI stops calling Gemini without touching a single user session.

The remaining features are built on top of this trust foundation:

Aurora Visibility Score (AVS) — a deterministic 0–100 score from live NOAA G-scale indices and solar wind speed
Real-time geomagnetic dashboard — G/R/S-scale meters, solar wind, 24/48h forecasts, auto-refreshing from NOAA SWPC
Interactive map — latitude-based aurora visibility bands that update with geomagnetic conditions
Green Path AI recommendations — 3 nearby dark-sky spots with public transit directions, CO₂ saved vs. solo driving, and dark-sky ratings — only unlocked when Auth0 confirms the user's identity
Per-user daily quota — Upstash Redis tracks each Auth0 user's Gemini calls (10/day) using a hashed sub claim as the key

Demo

🔗 Project URL: https://aurora-path.vercel.app/

The dashboard loads with live NOAA data immediately. Click "Find My Green Path" — Auth0 Universal Login appears if you're not signed in. Once authenticated, the AI agent (operating under its own M2M credential) generates sustainable viewing routes near your GPS location.

⚠️ Hackathon Note: Green Path uses Google AI Studio free tier (100 req/day shared). If it returns an error, the daily quota may be exhausted. The Aurora dashboard always works regardless.

Code

klee1611 / AuroraPath

🌌 Carbon-optimized aurora sighting dashboard — Earth Day 2026 Hackathon

AuroraPath 🌌

Sustainable Aurora Viewing — Earth Day Hackathon 2026

A real-time, carbon-optimized dashboard for aurora borealis sightings Built for the dev.to Earth Day Weekend Challenge.

🌍 What Is AuroraPath?

AuroraPath connects people with Earth's most spectacular natural phenomenon — the aurora borealis — while promoting sustainable travel. Instead of jumping in a car and driving to a dark-sky spot, AuroraPath shows you the best eco-friendly routes: public transit, carpooling, and low-carbon options, each with real CO₂ savings so you can chase the lights and tread lightly on the planet.

AuroraPath combines live NOAA space weather data with Google Gemini AI to help you:

Track real-time aurora activity — Aurora Visibility Score (AVS), G/R/S-scale meters, solar wind speed
See where auroras are visible — Interactive map with latitude visibility bands that update with geomagnetic conditions
Find sustainable viewing routes — AI-generated "Green Path" recommendations with carbon savings, public transit…

View on GitHub

How I Built It

Architecture

Two-Layer Auth0 Identity Model

The most interesting architectural decision was treating user identity and AI agent identity as separate
concerns:

Layer 1 — User Auth (Regular Web App):

User → Auth0 Universal Login → Session cookie (httpOnly, SameSite)
                                      ↓
/api/green-path checks getSession() → rejects anonymous requests (401)

Layer 2 — Agent Auth (M2M Application):

/api/green-path → Auth0 /oauth/token (client_credentials grant)
                        ↓
                M2M access token → logged as agentId in every response 
                (revocable independently of all user sessions)

Every AI recommendation response includes:

 {
   "agentId": "auth0-m2m|...",
   "generatedAt": "2026-04-19T...",
   "quota": { "remaining": 4, "limit": 5, "resetAt": "..." }
 }

This makes the AI fully auditable: you know who asked (Auth0 user sub) and who acted (Auth0 M2M agent ID) for every call.

Aurora Visibility Score (AVS)

Rather than showing raw space-weather indices, a deterministic scoring model converts them to a 0–100 scale:

AVS = (G-Scale/5 × 65) + (max(windSpeed − 300, 0)/500 × 25) + forecastBonus

G-Scale (65% weight) — NOAA's geomagnetic storm index, the primary aurora driver
Solar wind speed (25% weight) — elevated wind (>300 km/s) correlates with aurora enhancement
Forecast bonus (+3–5 pts) — rewards stable or improving 24h conditions

The AVS gates the Green Path feature: users below AVS 10 ("None" activity) cannot trigger AI recommendations — there's no point generating eco-travel routes when there's nothing to see.

Gemini Green Path

The Gemini prompt injects the AVS score, G-scale, and reverse-geocoded region (resolved server-side to protect user GPS privacy), then requests structured JSON directly — no markdown parsing needed. Before any Gemini call:

Auth0 session verified (user layer)
Auth0 M2M token fetched (agent layer)
Upstash Redis quota checked (ratelimit:{sha256(userId)[0:32]}:{YYYY-MM-DD})
Input sanitized (sanitizeRegion() strips control chars, caps at 100 chars)
Gemini called with 30s timeout

Security Hardening

Full 7-phase audit conducted:

Per-user Gemini quota via Upstash Redis (hashed sub, in-memory fallback for dev)
IP rate limiting (30 req/min) on public /api/aurora
Server-side Nominatim proxy — raw GPS never leaves the server
5 HTTP security headers: HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy
CORS restricted to own AUTH0_BASE_URL origin

Prize Categories

🔐 Best Use of Auth0 for Agents - AuroraPath implements the full Auth0 for Agents pattern: a dedicated M2M application gives the Gemini AI orchestrator its own managed identity, completely decoupled from user auth.
Every AI recommendation is traceable to both a human (user.sub) and a machine (agentId). The M2M credential can be rotated or revoked without impacting any user session. The per-user daily quota uses the Auth0 sub claim (SHA-256 hashed) as the Redis key — Auth0 identity drives resource governance end-to-end.

✨ Best Use of Google Gemini - Gemini 1.5 Flash powers the Green Path feature — generating 3 location-aware sustainable aurora viewing recommendations as structured JSON, dynamically conditioned on the live AVS score and geomagnetic context. The model is only invoked after passing both Auth0 authentication layers and the Upstash quota check.

Never Miss an AI Hackathon Again: Building an Autonomous Discovery Agent with Notion & Brave MCP

Kourtney Lee — Mon, 30 Mar 2026 00:10:15 +0000

This is a submission for the Notion MCP Challenge

What I Built

HackathonSniper is an autonomous AI agent designed to eliminate "hackathon fatigue." If you're like me, you spend hours every month checking Devpost, DoraHacks, and Dev.to just to find one hackathon that fits your niche.

HackathonSniper turns this manual hunt into an automated pipeline. It doesn't just "search"—it thinks. It uses the Model Context Protocol (MCP) to bridge the gap between AI reasoning and the real web.

Video Demo

Show us the code

klee1611 / HackathonSniper

AI-powered hackathon discovery agent using Brave Search + Notion MCP

Hackathon Sniper 🎯 — AI-Powered Hackathon Discovery Agent

Hackathon Sniper is a TypeScript agent that automatically discovers, evaluates, and tracks hackathons using AI-powered analysis, real MCP server integration, and strict environment separation. Point it at the web; it returns only the hackathons worth entering.

What it does in one sentence: Hackathon Sniper searches the web for hackathons, scores each one against your criteria with a Groq-powered AI evaluator, and saves qualified results directly to a Notion database — all in a single command.

Features ✨

Intelligent Search 🔍 — Real Brave Search MCP server integration
AI Evaluation 🤖 — Groq-powered hackathon qualification analysis
Notion Integration 📊 — Real Notion MCP server for storage and tracking
Test Isolation 🎭 — Complete environment isolation for testing (zero external dependencies)
Fast Development ⚡ — Hot reload, comprehensive Makefile, pnpm package management
Type Safety 🛡️ — End-to-end TypeScript with Zod schema validation
Robust Testing…

View on GitHub

The Technical Architecture

The agent follows a rigorous 3-phase lifecycle:

🔍 The Hunt (Brave Search MCP): It performs targeted searches across the web to find new hackathon announcements, even those buried in blog posts or obscure landing pages.
🤖 The Vetting (Groq LLM): Every discovery is analyzed by a Llama-3 model. It evaluates the prize pool, solo-friendliness, AI relevance, and proximity to the deadline.
📊 The Storage (Notion MCP): Qualified opportunities are instantly synced to a beautifully structured Notion database, complete with metadata, deadlines, and AI-generated summaries.

How I Used Notion MCP

The Notion MCP Server (@notionhq/notion-mcp-server) is the "nervous system" of this project. It transforms a simple script into a powerful productivity tool by allowing the AI to interact with my Notion workspace as if it were a native application.

Instead of writing complex, boilerplate-heavy API calls to the Notion REST API, the Notion MCP is integrated. This allowed the agent to:

Dynamic Schema Mapping: The agent automatically maps structured AI evaluation objects to Notion database properties (Dates, Checkboxes, URLs, and Rich Text).
Process Isolation: By using the MCP StdioClientTransport, the Notion integration runs in its own isolated process, managed entirely by the Model Context Protocol.
Automated Workflows: The agent uses the create_notion_page tool provided by the MCP server to dynamically populate my "Hackathon Scout" dashboard.

Wrapping Up

This integration unlocks a "set and forget" workflow. I can run HackathonSniper as a background task, and my Notion workspace stays updated with a high-signal, low-noise list of opportunities. It’s not just data entry; it’s an autonomous data clerk powered by Notion MCP.