GitHub - singhalgauri/CitySync

AI-Powered Municipal Complaint Management Platform

Smart. Transparent. Impactful.

Bridging the gap between Nagpur's citizens and municipal departments through intelligent complaint routing, real-time tracking, and AI-driven prioritization.

📋 Table of Contents

Overview
Live Architecture
Key Features
Tech Stack
Getting Started
Environment Variables
Database Schema
API Reference
Future ML Roadmap
Project Structure
Contributing
License

🌆 Overview

CitySync is a full-stack, AI-augmented civic platform built specifically for Nagpur, India, enabling citizens to report municipal issues (roads, water, electricity) and track their resolution in real time. The platform connects three actor types — Citizens, Zonal Officers, and City Administrators — through role-based dashboards backed by a shared PostgreSQL database.

Every pothole, broken streetlight, and burst pipe reported via CitySync is automatically scored for urgency and routed to the correct department — no manuals, no middlemen.

What Makes CitySync Different?

Traditional System	CitySync
Paper/phone complaints	Real-time multi-channel (Web + WhatsApp)
Manual priority assessment	AI-powered Gemini 2.5 scoring
No duplicate detection	Geo-clustering deduplicates within 50 m
Status via phone calls	Live ticket tracking with short IDs
No spatial analytics	Interactive city-wide heatmap
Department chosen by clerk	Auto-corrected by AI

🏗 Live Architecture

┌──────────────────────────────────────────────────────────────┐
│                        CITIZENS                              │
│          Web Dashboard  ◄──►  WhatsApp Bot (Baileys)         │
└──────────────────┬───────────────────────────────────────────┘
                   │  HTTPS / REST
┌──────────────────▼───────────────────────────────────────────┐
│              Next.js 16 App Router (Edge-ready)              │
│  ┌──────────┐  ┌──────────┐  ┌───────────┐  ┌────────────┐  │
│  │ /reports │  │/priority │  │/heatmap   │  │/escalation │  │
│  │   API    │  │  Engine  │  │   API     │  │    API     │  │
│  └────┬─────┘  └────┬─────┘  └─────┬─────┘  └──────┬─────┘  │
└───────┼─────────────┼──────────────┼───────────────┼────────┘
        │             │              │               │
        ▼             ▼              │               │
┌───────────────┐  ┌──────────────┐ │               │
│  Supabase DB  │  │ Gemini 2.5   │ │               │
│  (PostgreSQL) │  │ Flash (AI)   │ │               │
│  + RLS + RPC  │  │              │ │               │
└───────┬───────┘  └──────────────┘ │               │
        │                           │               │
        ▼                           ▼               ▼
┌──────────────────────────────────────────────────────────────┐
│              Role-Based Dashboards                           │
│   Civilian Portal │ Admin Overview │ Zonal Officer Panel     │
└──────────────────────────────────────────────────────────────┘

✨ Key Features

👤 Civilian Portal

The citizen-facing interface allows residents to submit, track, and upvote civic complaints with zero bureaucratic friction.

Complaint Submission

Multi-step form selecting Department → Issue Type → Description → Photo → Location
GPS-aware address resolution with manual fallback
Ghost Mode — privacy-preserving anonymous reporting (user ID is SHA-256 hashed before storage)
Image evidence mandatory — uploaded to Supabase Storage with public CDN URL
Immediate ticket ID (CS-XXXX-YYYY format) returned after submission

Real-Time Tracking

Live status dashboard: Pending → In Progress → Resolved
Upvote mechanism to signal complaint importance to officers
Visual status badges with color-coded state indicators

City Pulse Heatmap

Interactive Leaflet.js map embedded in the civilian dashboard
Heat intensity reflects density of active (non-resolved) issues in each area
Zoomable, pannable — built on OpenStreetMap tiles

QR-Based WhatsApp Access

Scannable QR code on the civilian dashboard for instant WhatsApp bot onboarding

🛡 Admin Dashboard

The city-level administrator has oversight over all complaints across all zones and departments.

System Overview

Total complaints, resolution rate, and AI-processing statistics at a glance
Department-wise breakdown: PWD, Electricity, Water
Escalation feed: all tickets with priority_score ≥ 9 surfaced automatically

Escalation Management

Mark tickets as High Priority or Escalate (forces priority to max)
Add administrative remarks visible to zonal officers
Filter by status: Pending / In Progress / Resolved / Rejected

City Pulse (Admin)

Admin-level heatmap showing the full spatial distribution of unresolved complaints
Zone-level breakdown (North / Central / East / West / South Nagpur)

AI Audit Trail

View Gemini's verification, urgency scores, and reasoning per complaint
See when the AI corrected a citizen's department selection

🗺 Zonal Officer Dashboard

Each of Nagpur's five zones (North, Central, East, West, South) gets a dedicated officer who sees only their zone's complaints.

Priority Queue

Complaints sorted by priority_score (0–9 scale) — highest urgency at top
Visual evidence display: citizen-uploaded images rendered inline
One-click status transitions: Pending → In Progress → Resolved

Assignments Done

Archive of completed work with before/after imagery
Resolution reports with officer notes and time taken

Zone-Aware Audit Map

Heatmap scoped to the officer's assigned zone only
Filters out resolved complaints automatically — shows only active workload

Ticket ID Search

Look up any complaint by short ticket ID across the zone

🤖 AI Priority Engine

The heart of CitySync's intelligence — a multi-signal scoring engine that runs every time a complaint is submitted.

Formula:

Priority = min(9, (P × I) + (V × U) / 10)

  P = similar complaints in a 500m radius in the last 15 days / 24
  I = (upvotes + 1) × 8                   [impact/community weight]
  V = AI verification score (0–10)         [Gemini: is this a real issue?]
  U = AI urgency score (0–10)              [Gemini: how dangerous/urgent?]

How It Works:

Similarity Clustering — When a complaint is submitted, the system checks for existing complaints of the same category within a 50-metre radius. Duplicates are batched into an existing cluster, incrementing its count.
Gemini 2.5 Flash Scoring — The description, category, department, and attached image (converted to base64) are sent to Google Gemini. The model returns:
- verification (0–10): Is this a genuine civic issue? Does the image match the claim?
- urgency (0–10): How dangerous or time-sensitive is it?
- corrected_department: If the citizen filed under the wrong department (e.g., a burst pipe reported to Electricity), Gemini reassigns it automatically.
- reasoning: A one-sentence explanation stored for audit.
Score Computation — All signals are combined and capped at 9.
Persistent Write — The score and AI metadata are written back to the reports table. The parent cluster's avg_priority is recomputed via a Supabase RPC function.
Department Auto-Correction — If Gemini detects a department mismatch, the report is re-routed to the correct department dashboard without any human intervention.

Key Design Choices:

Scoring is fire-and-forget (runs in the background post-insertion) so the citizen's POST request returns immediately.
If Gemini is unavailable, the score defaults gracefully to 0 (community signals alone drive ranking).
Priority = 9 triggers automatic surfacing in the Admin escalation feed.

💬 WhatsApp Bot

A standalone Node.js service (in /bot) using Baileys (WhatsApp Web multi-device library) that allows citizens to file complaints via WhatsApp without installing any app.

Conversation Flow (State Machine):

Start / Hi / Menu
  └─► [1] File Complaint
        └─► Select Department  (PWD / Electricity / Water)
              └─► Select Issue Type
                    └─► Describe the problem (≥10 chars)
                          └─► 📷 Send photo (mandatory)
                                └─► 📍 Share live location (mandatory)
                                      └─► Confirm (Y/N)
                                            └─► ✅ Ticket Created (Short ID returned)
  └─► [2] Track Complaint  →  Enter Short ID  →  Status Card
  └─► [3] Privacy Policy

Technical Details:

Sessions stored in-memory per WhatsApp JID (jid → {state, data})
Images uploaded to Supabase Storage before the complaint is submitted
Complaints POSTed to the same /api/reports endpoint as the web dashboard — single source of truth
Short IDs (CS-XXXX-9999) generated with Nano ID for shareable tracking
Full privacy policy served as plain text on request

🔥 City Pulse Heatmap

Built with Leaflet.js + leaflet.heat and rendered via react-leaflet:

Civilian view: Aggregated heatmap of all active issues across Nagpur
Admin view: Full city view with zone labels and complaint density
Zonal Officer view: Zone-scoped view filtered to their jurisdiction
Heatmap points use complaint coordinates with intensity proportional to priority_score
Automatically excludes resolved/completed complaints
Data served via /api/heatmap — a dedicated endpoint with RLS bypass via supabaseAdmin

🛠 Tech Stack

Layer	Technology
Framework	Next.js 16.2 (App Router, React 19)
Language	TypeScript 5
Styling	TailwindCSS 4 + Framer Motion
Database	Supabase (PostgreSQL + RLS + RPCs)
Storage	Supabase Storage (CDN-backed image hosting)
AI / LLM	Google Gemini 2.5 Flash (`@google/generative-ai`)
Maps	Leaflet.js + react-leaflet + leaflet.heat
WhatsApp	Baileys (multi-device WA Web API)
Icons	Lucide React
Animations	Framer Motion
Bot Runtime	Node.js (ES Modules)

🚀 Getting Started

Prerequisites

Node.js 20+
A Supabase project
A Google AI Studio API key (Gemini)
A WhatsApp account for the bot (scan QR on first run)

Web App

# Clone the repo
git clone https://github.com/singhalgauri/CitySync.git
cd CitySync

# Install dependencies
npm install

# Set up environment (see below)
cp .env.example .env.local

# Run migrations against your Supabase project
# (apply files in supabase/migrations/ via Supabase dashboard SQL editor)

# Start development server
npm run dev

The app will be available at http://localhost:3000.

WhatsApp Bot

cd bot
npm install

# Copy and configure bot env
cp .env.example .env

# Start the bot (scan QR code shown in terminal on first run)
node src/index.js

🔐 Environment Variables

Web App (`.env.local`)

# Supabase
NEXT_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_anon_key
SUPABASE_SERVICE_ROLE_KEY=your_service_role_key

# Google Gemini AI
GEMINI_API_KEY=your_gemini_api_key

WhatsApp Bot (`bot/.env`)

SUPABASE_URL=https://your-project.supabase.co
SUPABASE_SERVICE_ROLE_KEY=your_service_role_key

🗄 Database Schema

Core Tables

-- Geo-spatial complaint clusters (deduplication unit)
clusters (
  id            UUID PRIMARY KEY,
  lat           FLOAT8,
  lng           FLOAT8,
  category      TEXT,
  zone          TEXT,         -- 'north' | 'central' | 'east' | 'west' | 'south'
  report_count  INT,
  avg_priority  FLOAT8
)

-- Individual complaint reports
reports (
  id                UUID PRIMARY KEY,
  cluster_id        UUID REFERENCES clusters(id),
  description       TEXT,
  category          TEXT,
  department        TEXT,     -- 'PWD' | 'Electricity' | 'Water'
  lat               FLOAT8,
  lng               FLOAT8,
  zone              TEXT,
  image_url         TEXT,
  status            TEXT,     -- 'pending' | 'in_progress' | 'resolved' | 'rejected'
  upvotes           INT       DEFAULT 0,
  hashed_user_id    TEXT,     -- SHA-256, NULL if ghost mode
  is_ghost          BOOLEAN   DEFAULT FALSE,
  priority_score    INT       DEFAULT 0,    -- 0–9
  ai_verification   INT       DEFAULT 0,    -- Gemini output
  ai_urgency        INT       DEFAULT 0,    -- Gemini output
  ai_processed      BOOLEAN   DEFAULT FALSE,
  remarks           TEXT,
  created_at        TIMESTAMPTZ DEFAULT NOW()
)

-- Zonal officer resolution reports
officer_reports (
  id             UUID PRIMARY KEY,
  report_id      UUID REFERENCES reports(id),
  officer_id     UUID,
  report_text    TEXT,
  image_url      TEXT,
  created_at     TIMESTAMPTZ DEFAULT NOW()
)

Custom RPCs

Function	Description
`find_nearby_cluster(lat, lng, category, radius_m)`	Returns the nearest matching cluster within `radius_m` metres
`update_cluster_avg_priority(cluster_id)`	Recomputes `avg_priority` for a cluster after a report is scored

📡 API Reference

Method	Endpoint	Description
`POST`	`/api/reports`	Submit a new complaint (with AI scoring)
`GET`	`/api/heatmap`	Get active complaint coordinates for heatmap
`GET`	`/api/priority/recalculate`	Recalculate scores for unprocessed reports
`GET`	`/api/escalation`	Fetch escalated complaints (score ≥ 9)
`PATCH`	`/api/escalation`	Escalate, flag, or remark on a complaint
`GET`	`/api/system-overview`	Admin stats: total, resolved, pending counts
`GET`	`/api/reports`	Fetch reports (scoped by zone/department)
`POST`	`/api/force-emergency`	Force a complaint to maximum priority
`POST`	`/api/chat`	Gemini-powered contextual Q&A for admin

🔮 Future ML Roadmap

CitySync's current AI integration uses prompt-based LLM scoring (Gemini Flash). The following roadmap outlines the transition to specialized, trainable ML models that will dramatically improve accuracy, speed, and operational insight.

1. Image Classification & Computer Vision

Current State: Gemini Flash performs multimodal analysis — it receives the complaint image as base64 alongside the text description and returns a verification score.

Problem: General-purpose LLMs are not optimized for detecting subtle infrastructure defects (hairline cracks in roads, partial waterlogging, sagging power lines). They can be fooled by irrelevant but city-themed images.

Planned Implementation:

Phase 1 — Dataset Collection:
  ├── Label historical complaint images by category
  │     (Pothole, Waterlogging, Broken Light, Garbage, etc.)
  ├── Augment with public civic datasets (COCO, India-specific municipal datasets)
  └── Build annotation pipeline for zonal officers to label resolved cases

Phase 2 — Model Training:
  ├── Fine-tune EfficientNet-B3 or MobileNetV4 for:
  │     (a) Multi-class issue classification (10+ categories)
  │     (b) Severity scoring (0–5 scale for road damage, water damage)
  │     (c) Binary validity detection (is this a real civic issue?)
  ├── Training infra: Google Vertex AI / HuggingFace Spaces
  └── Model versioning via MLflow

Phase 3 — Integration:
  ├── Replace Gemini verification call in getAiScores() with
  │     dedicated vision model endpoint
  ├── Gemini retained only for department correction and NLP reasoning
  └── Confidence threshold → auto-reject spam below 0.3 confidence

Expected Outcome:
  → 40% reduction in false-positive complaints
  → Sub-200ms classification latency (vs. 2-4s Gemini calls)
  → Category auto-fill from image alone (no citizen selection needed)

2. ETA Estimation & Resolution Forecasting

Current State: No time estimate is given to citizens. Status changes from "Pending" to "In Progress" to "Resolved" with no predicted timeline.

Problem: Citizens have no expectation of when their complaint will be resolved, leading to distrust and repeat submissions.

Planned Implementation:

Feature Engineering from Historical Data:
  ├── department × category × zone combinations
  ├── day-of-week / season / weather patterns
  ├── officer workload (pending assignments per officer)
  ├── priority_score of the complaint
  └── complaint cluster size (number of similar nearby reports)

Model Architecture:
  ├── Gradient Boosted Regressor (XGBoost / LightGBM) for:
  │     → Predicted hours to "In Progress" transition
  │     → Predicted hours to "Resolved" transition
  └── Calibration layer for 80th-percentile confidence intervals
        (display range, not point estimate, to citizens)

Integration Points:
  ├── POST /api/reports: ETA computed and stored as eta_hours field
  ├── Civilian dashboard: "Expected resolution by: [date]" badge
  ├── Admin dashboard: Overdue complaint alerts when ETA breached
  └── Weekly ETA accuracy report for admin (RMSE per zone/department)

Data Requirements:
  → Minimum 500 resolved complaints with timestamps per department
  → 3-month historical baseline before model is reliable

3. AI Work Verification & Completion Validation

Current State: Zonal officers manually mark complaints as "Resolved" by uploading a completion report with an after-image. There is no automated check that the issue was actually fixed.

Problem: Officers may upload irrelevant images or mark issues resolved prematurely without actual fieldwork. Citizens cannot verify the fix.

Planned Implementation:

Before/After Change Detection:
  ├── Compare citizen's evidence image (before) with officer's
  │     completion image (after) using siamese network or
  │     contrastive learning model
  ├── Classify pairs as: Fixed / Partially Fixed / Unchanged
  └── Score: "Work Completion Confidence" (0–100%)

GPS Timestamp Verification:
  ├── Require officer app to embed EXIF GPS + timestamp in
  │     completion photo
  ├── Validate that completion photo was taken within:
  │     (a) 50m of the original complaint coordinates
  │     (b) After the "In Progress" status was set
  └── Flag suspicious submissions (same image hash, wrong GPS)

Citizen Feedback Loop:
  ├── Push WhatsApp notification when complaint is marked resolved
  ├── Citizen rates actuality: ✅ Fixed / ⚠️ Partially Fixed / ❌ Not Fixed
  ├── Negative feedback auto-reopens the complaint
  └── Officer reliability score updated based on citizen feedback

Integration:
  ├── POST /api/reports/{id}/verify (officer submits completion proof)
  ├── Background vision model validates before/after pair
  ├── If confidence < 60%, flag for admin review (don't auto-approve)
  └── Admin dashboard: "Pending Verification" queue

Long-term:
  → Officer performance scorecards based on verification acceptance rate
  → Gamification: top-rated officers get highlighted in admin dashboard

4. Predictive Maintenance & Proactive Alerts

Current State: CitySync is entirely reactive — issues are reported by citizens after they occur.

Planned Implementation:

Spatial-Temporal Pattern Mining:
  ├── Identify recurring hotspots: areas with 3+ complaints of
  │     same type in rolling 30-day window → "Chronic Issue Zone"
  ├── Correlate with city infrastructure age data (if available from NMC)
  └── Generate pre-emptive work orders for chronic zones

Seasonal Predictive Alerts:
  ├── Before monsoon: flag low-lying zones historically prone to waterlogging
  ├── Before summer: flag transformers/lines with past fault history
  └── Alerts sent to relevant department heads via admin dashboard

Anomaly Detection:
  ├── LSTM / Isolation Forest on daily complaint volume per zone
  ├── Sudden spike in a zone → early warning of infrastructure failure
  └── Admin notified via dashboard banner + email

Infrastructure:
  ├── Scheduled cron job (Supabase Edge Functions)
  ├── Pattern analysis runs nightly on resolved complaint history
  └── Output: "Predicted Risk Zone" overlay on admin heatmap

5. NLP Intent Classification & Auto-Routing

Current State: Citizens pick their department manually; Gemini corrects obvious errors but requires a full LLM call.

Planned Implementation:

Lightweight NLP Classifier:
  ├── Fine-tune DistilBERT / MobileBERT on complaint descriptions
  ├── Output: department + category + severity label
  └── Runs client-side (ONNX.js) for zero-latency pre-fill

Multilingual Support:
  ├── Support Marathi (primary local language in Nagpur) and Hindi
  ├── Integrate IndicBERT or similar multilingual fine-tuned model
  └── WhatsApp bot accepts complaints in Marathi/Hindi/English

Auto-Routing Pipeline:
  ├── NLP classifier runs on description text at form fill time
  ├── Suggests Department + Category to citizen (editable)
  ├── If citizen accepts suggestion, skip Gemini department-correction step
  └── Reduces Gemini API usage by ~60%, cutting costs

ML Integration Architecture (Target State)

Complaint Submitted
        │
        ▼
┌───────────────────┐      ┌─────────────────────┐
│ NLP Classifier    │─────►│ Department + Category│
│ (DistilBERT/ONNX) │      │ Auto-filled           │
└───────────────────┘      └──────────┬──────────┘
                                      │
                                      ▼
                           ┌─────────────────────┐
                           │ Vision Classifier    │
                           │ (EfficientNet B3)    │
                           │ → Validity Score     │
                           │ → Severity Score     │
                           └──────────┬──────────┘
                                      │
                                      ▼
                           ┌─────────────────────┐
                           │ Priority Engine      │
                           │ (ML scores + P + I)  │
                           │ → Final Score 0–9    │
                           └──────────┬──────────┘
                                      │
                                      ▼
                           ┌─────────────────────┐
                           │ ETA Estimator        │
                           │ (XGBoost Regressor)  │
                           │ → Resolution Date    │
                           └──────────┬──────────┘
                                      │
                                      ▼
                           ┌─────────────────────┐
                           │ Work Verifier         │
                           │ (Siamese Net)         │
                           │ → Completion %       │
                           └─────────────────────┘

📁 Project Structure

CitySync/
├── src/
│   ├── app/
│   │   ├── api/
│   │   │   ├── reports/          # POST: Submit complaint, trigger AI scoring
│   │   │   ├── heatmap/          # GET: Active complaint coordinates
│   │   │   ├── priority/         # Priority recalculation endpoints
│   │   │   ├── escalation/       # Admin escalation management
│   │   │   ├── system-overview/  # Admin stats aggregation
│   │   │   ├── force-emergency/  # Override-to-max-priority
│   │   │   └── chat/             # Gemini chat for admin Q&A
│   │   ├── dashboard/
│   │   │   ├── civilian/         # Citizen portal
│   │   │   ├── admin/            # City administrator panel
│   │   │   └── zonal-officer/    # Zone-scoped officer view
│   │   ├── login/                # Role-based authentication
│   │   └── register/             # New user registration
│   ├── lib/
│   │   ├── priority.ts           # AI priority scoring engine (Gemini + formula)
│   │   ├── zones.ts              # Nagpur zone definitions + geo-utilities
│   │   ├── auth-context.tsx      # React auth state provider
│   │   └── supabase/             # Supabase client (anon + admin)
│   └── components/               # Shared UI components
├── bot/
│   ├── src/
│   │   ├── index.js              # Baileys WhatsApp client entrypoint
│   │   ├── handler.js            # State-machine message router
│   │   ├── store.js              # Supabase complaint storage
│   │   ├── sessions.js           # In-memory session management
│   │   └── messages.js           # Message templates
│   └── data/
│       └── privacy.txt           # Privacy policy text
├── supabase/
│   └── migrations/               # SQL schema migrations
│       ├── add_priority_columns.sql
│       ├── add_priority_rpc.sql
│       ├── add_zone_column.sql
│       └── fix_priority_column_types.sql
├── public/                       # Static assets (logo, QR code)
├── .env.example                  # Environment variable template
└── package.json

🤝 Contributing

We welcome contributions! CitySync is being built as a reference implementation for AI-assisted civic tech in Indian municipalities.

Fork the repo and create a feature branch: git checkout -b feat/your-feature
Follow the existing code style (TypeScript strict, ESLint configured)
Add a migration file if you modify the database schema
Submit a PR with a clear description of changes and screenshots where relevant

Good first issues:

Add support for more Nagpur departments (e.g., Solid Waste, Garden)
Implement complaint search by address text
Add Marathi language support in the WhatsApp bot
Build officer mobile PWA for field use

📄 License

This project is licensed under the MIT License. See LICENSE for details.

Built with ❤️ for smarter cities, starting with Nagpur.

CitySync — Because every complaint deserves an answer.

Name		Name	Last commit message	Last commit date
bot		bot
public		public
scratch		scratch
src		src
supabase/migrations		supabase/migrations
.gitignore		.gitignore
AGENTS.md		AGENTS.md
CLAUDE.md		CLAUDE.md
README.md		README.md
eslint.config.mjs		eslint.config.mjs
next.config.ts		next.config.ts
package-lock.json		package-lock.json
package.json		package.json
postcss.config.mjs		postcss.config.mjs
tsconfig.json		tsconfig.json

Latest commit

History

Folders and files

Repository files navigation

AI-Powered Municipal Complaint Management Platform

📋 Table of Contents

🌆 Overview

What Makes CitySync Different?

🏗 Live Architecture

✨ Key Features

👤 Civilian Portal

🛡 Admin Dashboard

🗺 Zonal Officer Dashboard

🤖 AI Priority Engine

💬 WhatsApp Bot

🔥 City Pulse Heatmap

🛠 Tech Stack

🚀 Getting Started

Prerequisites

Web App

WhatsApp Bot

🔐 Environment Variables

Web App (.env.local)

WhatsApp Bot (bot/.env)

🗄 Database Schema

Core Tables

Custom RPCs

📡 API Reference

🔮 Future ML Roadmap

1. Image Classification & Computer Vision

2. ETA Estimation & Resolution Forecasting

3. AI Work Verification & Completion Validation

4. Predictive Maintenance & Proactive Alerts

5. NLP Intent Classification & Auto-Routing

ML Integration Architecture (Target State)

📁 Project Structure

🤝 Contributing

📄 License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Web App (`.env.local`)

WhatsApp Bot (`bot/.env`)