sync: backend from github@cc8365e9

.space.yaml

@@ -0,0 +1,9 @@
+---
+title: AgroMind Backend
+sdk: docker
+app_port: 8000
+emoji: 🌾
+colorFrom: green
+colorTo: blue
+pinned: false
+license: isc

Dockerfile

@@ -0,0 +1,87 @@
+# Unified Dockerfile for Hugging Face Spaces deployment
+# Runs BOTH the Node.js backend (port 7860) and the Python AI backend (port 5000)
+# in a single container so ML model requests are proxied to localhost:5000.
+
+FROM node:22-bookworm-slim
+
+WORKDIR /app
+
+# Install Python 3, pip and build deps needed by both stacks
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 \
+    python3-pip \
+    python3-sklearn \
+    build-essential \
+    pkg-config \
+    wget \
+    curl \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Node.js backend ──────────────────────────────────────────────────────────
+COPY backend/package*.json ./
+ENV NODE_ENV=production
+RUN npm install --omit=dev
+
+COPY backend/ ./
+
+# ── Python AI backend ────────────────────────────────────────────────────────
+COPY ai-backend/requirements.txt /ai-backend/requirements.txt
+RUN pip3 install --no-cache-dir --break-system-packages -r /ai-backend/requirements.txt
+
+COPY ai-backend/ /ai-backend/
+
+# Point the Node backend at the co-located AI service
+ENV AI_BACKEND_URL=http://localhost:5000
+
+# ── Create non-root user (uid 1000) for HF Spaces ───────────────────────────
+RUN set -ex && \
+    if ! getent group 1000 > /dev/null 2>&1; then \
+      groupadd -g 1000 nodejs; \
+    fi && \
+    GROUP_NAME=$(getent group 1000 | cut -d: -f1) && \
+    if ! getent passwd 1000 > /dev/null 2>&1; then \
+      useradd -m -u 1000 -g ${GROUP_NAME} appuser; \
+    fi && \
+    chown -R 1000:1000 /app /ai-backend
+
+# ── Startup script ───────────────────────────────────────────────────────────
+# Launches the Python AI backend in the background, then starts Node.js
+COPY <<'EOF' /start.sh
+#!/bin/sh
+echo "[startup] Starting AI backend on port 5000..."
+cd /ai-backend && gunicorn --bind 0.0.0.0:5000 --workers 2 --timeout 180 --preload app:app &
+AI_PID=$!
+
+# Wait for AI backend to be ready (up to 30 s)
+READY=0
+for i in $(seq 1 30); do
+  if wget -q --spider http://127.0.0.1:5000/health 2>/dev/null; then
+    echo "[startup] AI backend is ready."
+    READY=1
+    break
+  fi
+  # Exit if the AI backend process died during startup
+  if ! kill -0 $AI_PID 2>/dev/null; then
+    echo "[startup] AI backend process exited unexpectedly."
+    break
+  fi
+  sleep 1
+done
+if [ "$READY" -eq 0 ] && kill -0 $AI_PID 2>/dev/null; then
+  echo "[startup] AI backend health check timed out after 30s; proceeding anyway."
+fi
+
+echo "[startup] Starting Node.js backend on port 7860..."
+cd /app && exec node server.js
+EOF
+RUN chmod +x /start.sh
+
+USER 1000
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://127.0.0.1:7860/health || exit 1
+
+CMD ["/start.sh"]

README.md

@@ -0,0 +1,333 @@
+---
+title: Agromind Backend
+colorFrom: green
+colorTo: blue
+sdk: docker
+app_port: 7860
+---
+
+# AgroMind: Where Farmers Meet AI & Technology for a Greener Future! 🌾
+
+![Alt Landing Page](frontend/src/assets/LandingPage.png)
+
+**AgroMind** is an innovative platform designed to empower farmers by connecting them with agricultural experts, AI-powered tools, and modern technology. Our goal is to make farming smarter, more efficient, and more sustainable.
+
+## 🚀 Key Features
+
+### Core Features
+- **Expert Consultations** - Real-time video calls and chat with agricultural experts
+- **AI-Powered Recommendations** - Crop, fertilizer, and yield predictions
+- **Task Management** - Goal-based scheduling and tracking
+- **Weather Alerts** - Real-time weather updates and recommendations
+- **Revenue Tracking** - Income and expense management
+
+### New Features (v2.0)
+
+| Feature | Description |
+|---------|-------------|
+| **Value Chain Marketplace** | Connect farmers, processors, and buyers for oilseed by-products |
+| **Hedging Platform** | Virtual hedging, price risk management, forward contracts |
+| **Crop Economics** | Comparative crop analysis, govt schemes, profitability simulation |
+| **Oil Palm Advisory** | Farmer profiling, ROI projections, gestation support tracking |
+| **Yield Optimization** | AI-driven yield predictions with intervention suggestions |
+| **Tariff Simulator** | Model impact of customs duty changes on prices |
+| **Millets Marketplace** | Specialized marketplace with traceability and offline support |
+| **CRM Machine Tracking** | Real-time tracking of crop residue management machines |
+| **CROPIC** | AI-based crop damage assessment for insurance |
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        Frontend                              │
+│                    (React.js + Vite)                        │
+└─────────────────────┬───────────────────────────────────────┘
+                      │
+      ┌───────────────┼───────────────┐
+      ▼               ▼               ▼
+┌──────────┐   ┌──────────┐   ┌──────────────┐
+│ Backend  │   │ AI Backend│   │ Smart Contracts│
+│ Node.js  │   │  Python  │   │   Solidity    │
+└────┬─────┘   └────┬─────┘   └──────────────┘
+     │              │
+     └──────┬───────┘
+            ▼
+      ┌──────────┐
+      │ MongoDB  │
+      │  Redis   │
+      └──────────┘
+```
+
+## 📦 Quick Start
+
+### Prerequisites
+- Node.js 20+
+- Python 3.11+
+- Docker & Docker Compose (recommended)
+- MongoDB
+
+### Local Development with Docker
+
+```bash
+# Clone repository
+git clone https://github.com/Anamitra-Sarkar/AgroMind.git
+cd AgroMind
+
+# Copy environment file
+cp .env.sample .env
+
+# Start all services
+docker-compose up -d
+
+# Access applications
+# Frontend: http://localhost:5173
+# Backend: http://localhost:8000
+# AI Backend: http://localhost:5000
+```
+
+### Manual Setup
+
+```bash
+# Backend
+cd backend && npm install && npm run dev
+
+# AI Backend
+cd ai-backend && pip install -r requirements.txt && python app.py
+
+# Frontend
+cd frontend && npm install && npm run dev
+```
+
+## 🔧 Environment Variables
+
+See [.env.sample](.env.sample) for all required environment variables.
+
+### Key Variables
+
+| Variable | Description |
+|----------|-------------|
+| `MONGO_URL` | MongoDB connection string |
+| `JWT_KEY` | JWT signing key |
+| `FRONTEND_URL` | Frontend URL for CORS |
+| `AI_BACKEND_URL` | AI backend URL |
+| `OPENWEATHER_API_KEY` | OpenWeather API key |
+| `GEMINI_API_KEY` | Google Gemini AI key |
+
+## 🛠️ Technology Stack
+
+### Frontend
+- React.js 18 + Vite
+- TailwindCSS + Material-UI
+- Chart.js + Recharts
+- Socket.IO Client
+- i18next (internationalization)
+
+### Backend
+- Node.js + Express.js
+- MongoDB + Mongoose
+- Redis (caching)
+- Socket.IO
+- JWT Authentication
+
+### AI Backend
+- Python + Flask
+- PyTorch + scikit-learn
+- LightGBM (price forecasting)
+- ResNet (image classification)
+
+### Infrastructure
+- Docker + Docker Compose
+- GitHub Actions CI/CD
+- Vercel (frontend hosting)
+- Hugging Face Spaces (backend hosting)
+- Prometheus + Grafana (monitoring)
+
+## 📚 API Documentation
+
+### Backend API Endpoints
+
+| Endpoint | Description |
+|----------|-------------|
+| `/api/auth/*` | Authentication |
+| `/api/valuechain/*` | Marketplace |
+| `/api/hedging/*` | Hedging platform |
+| `/api/crop-economics/*` | Crop comparison |
+| `/api/oilpalm/*` | Oil palm advisory |
+| `/api/crm/*` | Machine tracking |
+| `/api/millets/*` | Millets marketplace |
+
+### AI Backend Endpoints
+
+| Endpoint | Description |
+|----------|-------------|
+| `/ai/price-forecast` | Price predictions |
+| `/ai/yield-predict` | Yield predictions |
+| `/ai/tariff-simulate` | Tariff impact simulation |
+| `/ai/cropic/analyze` | Crop damage analysis |
+| `/crop_recommendation` | Crop recommendations |
+| `/fertilizer_prediction` | Fertilizer suggestions |
+
+📄 Full API documentation: [docs/postman_collection.json](docs/postman_collection.json)
+
+## 🧪 Testing
+
+```bash
+# Backend tests
+cd backend && npm test
+
+# AI Backend tests
+cd ai-backend && pytest tests/ -v
+
+# Frontend tests
+cd frontend && npm test
+
+# E2E tests
+cd frontend && npm run cypress:open
+
+# Smart contract tests
+cd backend/contracts && npm test
+```
+
+### AI Backend Testing Details
+
+The AI backend now includes comprehensive test coverage with:
+
+**Test Coverage:**
+- Unit tests for model predictions (`tests/test_models.py`) - 15 passing, 5 skipped
+- Integration tests for all API endpoints (`tests/test_api_integration.py`)
+- Existing validation tests (`tests/test_endpoints.py`)
+
+**Test Features:**
+- Mocked models for fast, deterministic tests (no HF downloads)
+- Retry logic testing with transient failures
+- Error handling and exception logging validation
+- Content-Type and JSON payload validation
+- Model loading and caching tests
+
+**Run with Coverage:**
+```bash
+cd ai-backend
+pytest tests/ -v --cov=. --cov-report=html
+```
+
+For detailed testing documentation and sample payloads, see [docs/TESTING.md](docs/TESTING.md).
+
+## 🚀 Deployment
+
+### Frontend → Vercel
+
+```bash
+cd frontend
+vercel --prod
+```
+
+### Hugging Face Spaces → Backend only
+
+To push only the `backend` and `ai-backend` folders (avoid large frontend/binary files), use the helper script:
+
+Example:
+
+```bash
+chmod +x scripts/push_to_hf.sh
+./scripts/push_to_hf.sh https://huggingface.co/spaces/<username>/<repo>
+```
+
+This creates a temporary git repo containing only `backend` and `ai-backend` and force-pushes `main` to the provided remote.
+
+### GitHub Action (recommended)
+
+You can automate the push using the provided GitHub Action. It creates a temporary repo with only `backend` and `ai-backend` and pushes it to your Hugging Face Space.
+
+1. Add a repository secret named `HF_TOKEN` containing a Hugging Face token with repo write access.
+2. Run the workflow manually from the Actions tab and provide the `hf_repo` input (e.g. `username/Agromind-backend`).
+
+Workflow options:
+- **hf_branch**: target branch on the Hugging Face repo (default `main`).
+- **force**: set to `true` to force-push the target branch (default `false`). Avoid force-push unless you intentionally want to overwrite history.
+- **dry_run**: set to `true` to prepare the temporary repo and list files without pushing (default `false`).
+
+Recommended safe flow:
+1. Run with `dry_run=true` to verify what will be pushed.
+2. Run with `force=false` to push to a branch without overwriting history. If you specifically need to replace the remote branch, set `force=true`.
+
+The workflow file is `.github/workflows/auto-sync-to-hf.yml` — it also runs
+automatically on every push to `main` that touches `backend/`, `ai-backend/`,
+`Dockerfile`, `.space.yaml`, or `README.md`, so a manual run is only needed
+for a dry run or to push to a non-default branch.
+
+
+### Backend → Hugging Face Spaces
+
+See [docs/deploy.md](docs/deploy.md) for detailed deployment instructions.
+
+### Required GitHub Secrets
+
+```
+VERCEL_TOKEN
+VERCEL_ORG_ID
+VERCEL_PROJECT_ID
+HF_TOKEN
+HF_BACKEND_SPACE_ID
+HF_AI_BACKEND_SPACE_ID
+```
+
+## 📁 Project Structure
+
+```
+AgroMind/
+├── frontend/           # React frontend
+├── backend/           # Node.js backend
+│   ├── routes/        # API routes
+│   ├── controllers/   # Route handlers
+│   ├── models/        # MongoDB models
+│   ├── middleware/    # Express middleware
+│   ├── socket/        # Socket.IO handlers
+│   └── contracts/     # Smart contracts
+├── ai-backend/        # Python AI backend
+│   ├── model/         # ML models
+│   └── tests/         # Python tests
+├── docs/              # Documentation
+├── config/            # Configuration files
+├── scripts/           # Utility scripts
+└── docker-compose.yml # Local development
+```
+
+## 📖 Documentation
+
+- [Architecture](docs/architecture.md) - System design and diagrams
+- [Deployment](docs/deploy.md) - Deployment instructions
+- [Security](docs/security.md) - Security checklist
+- [ML Models](docs/models.md) - Model documentation
+- [Local Setup](docs/run_locally.md) - Local development guide
+
+## 🔐 Security
+
+- JWT-based authentication
+- Rate limiting and CORS
+- Input validation and sanitization
+- Encrypted data storage
+- Regular dependency scanning
+
+See [docs/security.md](docs/security.md) for the full security checklist.
+
+## 🤝 Contributing
+
+We welcome contributions! Please:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit changes (`git commit -m 'Add amazing feature'`)
+4. Push to branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the ISC License.
+
+## 📞 Support
+
+For support, email support@agromind.app or join our community.
+
+---
+
+**AgroMind: Empowering farmers with technology for a greener, smarter future!** 🌱

ai-backend/.gitignore

@@ -0,0 +1,4 @@
+venv/
+__pycache__/
+*.pyc
+.venv/

ai-backend/Dockerfile

@@ -0,0 +1,45 @@
+# AI Backend Dockerfile
+FROM python:3.11-slim as base
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY requirements.txt .
+
+# Development stage
+FROM base as development
+RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir pytest pytest-cov httpx black flake8 isort
+COPY . .
+EXPOSE 5000
+CMD ["python", "-m", "flask", "run", "--host=0.0.0.0", "--port=5000", "--reload"]
+
+# Production stage
+FROM base as production
+
+# Install production dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create non-root user
+RUN groupadd -r appuser && useradd -r -g appuser appuser && \
+    chown -R appuser:appuser /app
+
+USER appuser
+
+EXPOSE 5000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:5000/health || exit 1
+
+# Use gunicorn for production
+CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "2", "--timeout", "120", "app:app"]

ai-backend/app.py

@@ -0,0 +1,1609 @@
+"""app.py
+
+AI backend Flask app.  All ML models are downloaded at runtime from
+Hugging Face Hub — no local binary weights are required.
+"""
+
+import io
+import os
+import json
+import pickle
+import logging
+import time as _time
+
+import requests as _requests
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from PIL import Image
+import torch
+import joblib
+import numpy as np
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+from model_utils import load_model_from_hf, predict
+
+# Import new infrastructure
+from src.logging_config import setup_logging, log_exception
+from src.error_handlers import register_error_handlers, validate_content_type, validate_json_payload
+from src.models import manager as model_manager
+from src.utils.retry_utils import retry_with_backoff, retry_model_inference
+
+# Setup structured logging
+logger = setup_logging(level=logging.INFO)
+
+_start_time = _time.time()
+
+_HF_INFERENCE_RETRY_DELAYS = (1, 2, 4)  # seconds between retries (3 attempts total)
+
+
+def _call_hf_inference_api(api_url: str, headers: dict, data: bytes, timeout: int = 60) -> "_requests.Response":
+    """POST to a Hugging Face Inference API endpoint with retries on network/DNS errors.
+
+    On persistent failure a :class:`requests.exceptions.RequestException` is
+    raised so callers can fall back to the local model path.
+    """
+    last_exc: "_requests.exceptions.RequestException | None" = None
+    for attempt, retry_delay in enumerate((*_HF_INFERENCE_RETRY_DELAYS, None)):
+        try:
+            return _requests.post(api_url, headers=headers, data=data, timeout=timeout)
+        except _requests.exceptions.RequestException as exc:
+            last_exc = exc
+            if retry_delay is not None:
+                logger.warning(
+                    "HF Inference API network error attempt %d/%d url=%s error=%s. "
+                    "Retrying in %ds.",
+                    attempt + 1, len(_HF_INFERENCE_RETRY_DELAYS) + 1, api_url, exc, retry_delay,
+                )
+                _time.sleep(retry_delay)
+            else:
+                logger.error(
+                    "HF Inference API failed after %d attempts url=%s error=%s. "
+                    "Verify HF_TOKEN and network/DNS access from this Space.",
+                    len(_HF_INFERENCE_RETRY_DELAYS) + 1, api_url, exc,
+                )
+    raise _requests.exceptions.RequestException(
+        f"Network/DNS failure after {len(_HF_INFERENCE_RETRY_DELAYS) + 1} attempts: {last_exc}"
+    ) from last_exc
+
+app = Flask(__name__)
+CORS(app)
+
+# Register centralized error handlers
+register_error_handlers(app)
+
+# ── HF repo IDs (override via env vars if needed) ──────────────────────────
+HF_REPO_CROP = os.environ.get(
+    "HF_REPO_CROP", "Arko007/agromind-crop-recommendation"
+)
+HF_REPO_FERTILIZER = os.environ.get(
+    "HF_REPO_FERTILIZER", "Arko007/agromind-fertilizer-prediction"
+)
+HF_REPO_LOAN = os.environ.get(
+    "HF_REPO_LOAN", "Arko007/agromind-loan-prediction"
+)
+HF_REPO_HARVEST = os.environ.get(
+    "HF_REPO_HARVEST", "Arko007/harvest-readiness-yolo11m"
+)
+
+device = model_manager.get_device()
+
+# ── Models are lazy-loaded on first request directly from HF Hub ──────────
+# Repos used:
+#   crop:       Arko007/agromind-crop-recommendation
+#   disease:    Arko007/nfnet-f1-plant-disease
+#   fertilizer: Arko007/agromind-fertilizer-prediction
+#   loan:       Arko007/agromind-loan-prediction
+try:
+    model_manager.initialize_models(load_all=False)
+except Exception as e:
+    log_exception(logger, e, "Error during model manager init")
+
+logger.info("AI backend startup complete. Ready to serve requests.")
+
+# Mapping for crop types
+crop_dict = {
+    1: "Rice", 2: "Maize", 3: "Jute", 4: "Cotton", 5: "Coconut", 6: "Papaya", 7: "Orange",
+    8: "Apple", 9: "Muskmelon", 10: "Watermelon", 11: "Grapes", 12: "Mango", 13: "Banana",
+    14: "Pomegranate", 15: "Lentil", 16: "Blackgram", 17: "Mungbean", 18: "Mothbeans",
+    19: "Pigeonpeas", 20: "Kidneybeans", 21: "Chickpea", 22: "Coffee"
+}
+
+# Mapping for soil and crop types (fertilizer prediction)
+soil_mapping = {
+    "Black": 0,
+    "Clayey": 1,
+    "Loamy": 2,
+    "Red": 3,
+    "Sandy": 4
+}
+
+crop_mapping = {
+    "Barley": 0,
+    "Cotton": 1,
+    "Ground Nuts": 2,
+    "Maize": 3,
+    "Millets": 4,
+    "Oil Seeds": 5,
+    "Paddy": 6,
+    "Pulses": 7,
+    "Sugarcane": 8,
+    "Tobacco": 9,
+    "Wheat": 10
+}
+
+
+@app.route("/")
+def index():
+    return jsonify({"message": "Welcome to the AI Backend API"})
+
+
+@app.route('/health')
+def health():
+    # Get model status from model manager
+    model_status = model_manager.get_model_status()
+    
+    return jsonify({
+        "status": "ok",
+        "version": "1.0.0",
+        "uptime": int(_time.time() - _start_time),
+        "models_loaded": model_status
+    })
+
+
+@app.route("/predict_disease", methods=["POST"])
+def predict_route():
+    # Lazy-load disease model from Arko007/nfnet-f1-plant-disease on first call
+    model = model_manager.get_model('disease_model', auto_load=True)
+    labels = model_manager.get_model('disease_labels', auto_load=True) or []
+    remedies = model_manager.get_model('disease_remedies', auto_load=True) or {}
+    if model is None:
+        return jsonify({"error": "Disease model unavailable — HF Hub download may have failed"}), 503
+    if "file" not in request.files:
+        return jsonify({"error": "no file part"}), 400
+    file = request.files["file"]
+    if file.filename == "":
+        return jsonify({"error": "empty filename"}), 400
+    try:
+        img_bytes = file.read()
+        pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+
+        # Determine crop filter from filename if present
+        filename_lower = file.filename.lower()
+        crop_filter = None
+        crop_mapping = {
+            "wheat": "Wheat__",
+            "potato": "Potato__",
+            "rice": "Rice__",
+            "corn": "Corn__",
+            "apple": "Apple__",
+            "cassava": "Cassava__",
+            "cherry": "Cherry__",
+            "chili": "Chili__",
+            "chilli": "Chili__",
+            "coffee": "Coffee__",
+            "cucumber": "Cucumber__",
+            "guava": "Gauva__",
+            "gauva": "Gauva__",
+            "grape": "Grape__",
+            "jamun": "Jamun__",
+            "lemon": "Lemon__",
+            "mango": "Mango__",
+            "peach": "Peach__",
+            "pepper": "Pepper_bell__",
+            "bell": "Pepper_bell__",
+            "pomegranate": "Pomegranate__",
+            "soybean": "Soybean__",
+            "soy": "Soybean__",
+            "strawberry": "Strawberry",
+            "sugarcane": "Sugarcane__",
+            "tea": "Tea__",
+            "tomato": "Tomato__"
+        }
+        for kw, prefix in crop_mapping.items():
+            if kw in filename_lower:
+                crop_filter = [lbl for lbl in labels if lbl.startswith(prefix)]
+                logger.info("Filtering classes for prefix '%s' based on filename '%s'", prefix, file.filename)
+                break
+
+        top_label, confidence, topk = predict(model, pil_img, labels, device, topk=5, crop_filter=crop_filter)
+
+        # Try to find remedies in a robust way to handle label-format differences
+        def find_remedy(label, remedies_dict):
+            if not remedies_dict:
+                return None
+            # direct match
+            if label in remedies_dict:
+                return remedies_dict[label]
+            # try common normalization variants
+            variants = set()
+            variants.add(label.replace('__', '___'))
+            variants.add(label.replace('___', '__'))
+            variants.add(label.replace('(', '').replace(')', ''))
+            variants.add(label.replace(' ', '_'))
+            variants.add(label.replace('-', '_'))
+            variants.add(label.lower())
+            variants.add(label.replace('__', ' ').lower())
+            for v in variants:
+                if v in remedies_dict:
+                    return remedies_dict[v]
+            # try case-insensitive match
+            for k in remedies_dict.keys():
+                if k.lower() == label.lower():
+                    return remedies_dict[k]
+            return None
+
+        remedy = find_remedy(top_label, remedies)
+        response = {
+            "label": top_label,
+            "confidence": confidence,
+            "remedies": remedy,
+            "topk": [{"label": l, "confidence": float(c)} for l, c in topk]
+        }
+        return jsonify(response)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/crop_recommendation", methods=["POST"])
+def crop_recommendation():
+    """Crop recommendation endpoint with robust error handling and logging."""
+    request_start = _time.time()
+    
+    # Validate Content-Type
+    is_valid, error_response = validate_content_type(request)
+    if not is_valid:
+        return jsonify(error_response), error_response['status']
+    
+    # Lazy-load from Arko007/agromind-crop-recommendation on first call (cached after)
+    crop_predict_model = model_manager.get_model('crop_model', auto_load=True)
+    crop_predict_sc = model_manager.get_model('crop_standard_scaler', auto_load=True)
+    crop_predict_ms = model_manager.get_model('crop_minmax_scaler', auto_load=True)
+    # Check model availability
+    if crop_predict_model is None or crop_predict_sc is None or crop_predict_ms is None:
+        logger.error("Crop recommendation: Model not loaded")
+        return jsonify({
+            "error": "Crop prediction model not loaded",
+            "message": "Service temporarily unavailable. Please try again later."
+        }), 500
+    
+    try:
+        # Validate JSON payload
+        required_fields = ['N', 'P', 'K', 'temperature', 'humidity', 'ph', 'rainfall']
+        is_valid, result = validate_json_payload(request, required_fields)
+        if not is_valid:
+            return jsonify(result), result['status']
+        
+        data = result
+        logger.info(f"Crop recommendation request: N={data.get('N')}, P={data.get('P')}, K={data.get('K')}")
+        
+        # Extract and validate features
+        try:
+            N = float(data['N'])
+            P = float(data['P'])
+            K = float(data['K'])
+            temp = float(data['temperature'])
+            humidity = float(data['humidity'])
+            ph = float(data['ph'])
+            rainfall = float(data['rainfall'])
+        except (ValueError, TypeError) as e:
+            logger.warning(f"Invalid data type in crop recommendation: {e}")
+            return jsonify({
+                "error": "Invalid data type",
+                "message": f"All numeric fields must be valid numbers: {str(e)}"
+            }), 400
+        
+        # Validate ranges
+        if not (0 <= N <= 100 and 0 <= P <= 100 and 0 <= K <= 100):
+            return jsonify({"error": "N, P, K values must be between 0 and 100"}), 400
+        if not (-10 <= temp <= 50):
+            return jsonify({"error": "Temperature must be between -10 and 50°C"}), 400
+        if not (0 <= humidity <= 100):
+            return jsonify({"error": "Humidity must be between 0 and 100%"}), 400
+        if not (0 <= ph <= 14):
+            return jsonify({"error": "pH must be between 0 and 14"}), 400
+        if not (0 <= rainfall <= 500):
+            return jsonify({"error": "Rainfall must be between 0 and 500mm"}), 400
+        
+        # Prepare features for prediction
+        feature_list = [N, P, K, temp, humidity, ph, rainfall]
+        single_pred = np.array(feature_list).reshape(1, -1)
+        
+        # Make prediction with retry wrapper
+        @retry_model_inference(max_attempts=2)
+        def make_prediction():
+            scaled_features = crop_predict_ms.transform(single_pred)
+            final_features = crop_predict_sc.transform(scaled_features)
+            return crop_predict_model.predict(final_features)
+        
+        prediction = make_prediction()
+        
+        # Get crop name
+        if prediction[0] in crop_dict:
+            crop = crop_dict[prediction[0]]
+            result = f"{crop} is the best crop to be cultivated right there."
+            
+            elapsed_ms = int((_time.time() - request_start) * 1000)
+            logger.info(f"Crop recommendation successful: {crop} (took {elapsed_ms}ms)")
+            
+            return jsonify({
+                "success": True,
+                "crop": crop,
+                "message": result,
+                "prediction_id": int(prediction[0]),
+                "input_data": {
+                    "nitrogen": N,
+                    "phosphorus": P,
+                    "potassium": K,
+                    "temperature": temp,
+                    "humidity": humidity,
+                    "ph": ph,
+                    "rainfall": rainfall
+                }
+            }), 200
+        else:
+            logger.warning(f"Crop recommendation: Unknown prediction ID {prediction[0]}")
+            return jsonify({
+                "success": False,
+                "message": "Could not determine the best crop with the provided data."
+            }), 200
+    
+    except Exception as e:
+        elapsed_ms = int((_time.time() - request_start) * 1000)
+        log_exception(logger, e, f"Crop recommendation failed after {elapsed_ms}ms")
+        return jsonify({
+            "error": "Internal server error",
+            "message": "An unexpected error occurred during prediction. Please try again later."
+        }), 500
+
+
+@app.route('/fertilizer_prediction', methods=['POST'])
+def fertilizer_prediction():
+    # Lazy-load from Arko007/agromind-fertilizer-prediction on first call
+    classifier_model = model_manager.get_model('fertilizer_classifier', auto_load=True)
+    label_encoder = model_manager.get_model('fertilizer_label_encoder', auto_load=True)
+    if classifier_model is None or label_encoder is None:
+        return jsonify({"error": "Fertilizer prediction model not loaded"}), 503
+    try:
+        # Get JSON data from request
+        data = request.get_json()
+
+        # Validate required fields
+        required_fields = ['temperature', 'humidity', 'moisture', 'soil_type', 'crop_type', 'nitrogen', 'potassium', 'phosphorus']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({
+                    "error": f"Missing required field: {field}"
+                }), 400
+
+        # Extract features
+        temp = int(data['temperature'])
+        humi = int(data['humidity'])
+        mois = int(data['moisture'])
+        soil_type = data['soil_type']
+        crop_type = data['crop_type']
+        nitro = int(data['nitrogen'])
+        pota = int(data['potassium'])
+        phosp = int(data['phosphorus'])
+
+        # Validate soil type
+        if soil_type not in soil_mapping:
+            return jsonify({
+                "error": f"Invalid soil_type. Must be one of: {list(soil_mapping.keys())}"
+            }), 400
+
+        # Validate crop type
+        if crop_type not in crop_mapping:
+            return jsonify({
+                "error": f"Invalid crop_type. Must be one of: {list(crop_mapping.keys())}"
+            }), 400
+
+        # Validate ranges
+        if not (0 <= temp <= 100):
+            return jsonify({"error": "Temperature must be between 0 and 100"}), 400
+        if not (0 <= humi <= 100):
+            return jsonify({"error": "Humidity must be between 0 and 100"}), 400
+        if not (0 <= mois <= 100):
+            return jsonify({"error": "Moisture must be between 0 and 100"}), 400
+        if not (0 <= nitro <= 100):
+            return jsonify({"error": "Nitrogen must be between 0 and 100"}), 400
+        if not (0 <= pota <= 100):
+            return jsonify({"error": "Potassium must be between 0 and 100"}), 400
+        if not (0 <= phosp <= 100):
+            return jsonify({"error": "Phosphorus must be between 0 and 100"}), 400
+
+        # Convert categorical inputs to numerical values
+        soil_encoded = soil_mapping[soil_type]
+        crop_encoded = crop_mapping[crop_type]
+
+        # Prepare input for prediction
+        input_data = [temp, humi, mois, soil_encoded, crop_encoded, nitro, pota, phosp]
+        input_array = np.array(input_data).reshape(1, -1)
+
+        # Make prediction
+        result_index = classifier_model.predict(input_array)
+        result_label = label_encoder.inverse_transform(result_index)
+
+        return jsonify({
+            "success": True,
+            "fertilizer": result_label[0],
+            "message": f"Predicted fertilizer is {result_label[0]}",
+            "input_data": {
+                "temperature": temp,
+                "humidity": humi,
+                "moisture": mois,
+                "soil_type": soil_type,
+                "crop_type": crop_type,
+                "nitrogen": nitro,
+                "potassium": pota,
+                "phosphorus": phosp
+            }
+        }), 200
+
+    except ValueError as e:
+        return jsonify({
+            "error": f"Invalid data type: {str(e)}"
+        }), 400
+    except Exception as e:
+        return jsonify({
+            "error": f"An error occurred: {str(e)}"
+        }), 500
+
+
+@app.route('/loan_prediction', methods=['POST'])
+def loan_prediction():
+    # Lazy-load from Arko007/agromind-loan-prediction on first call
+    price_model = model_manager.get_model('loan_price_model', auto_load=True)
+    approval_model = model_manager.get_model('loan_approval_model', auto_load=True)
+    if price_model is None or approval_model is None:
+        return jsonify({"error": "Loan prediction model not loaded"}), 503
+    try:
+        data = request.get_json()
+
+        # Validate required fields
+        required_fields = ['area', 'land_contour', 'distance_from_road', 'soil_type', 'income', 'loan_request']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({'error': f'Missing required field: {field}'}), 400
+
+        # Extract features
+        area = float(data['area'])
+        land_contour = data['land_contour']
+        distance_from_road = float(data['distance_from_road'])
+        soil_type = data['soil_type']
+        income = float(data['income'])
+        loan_request = float(data['loan_request'])
+
+        # Prepare input for prediction
+        input_data_price = pd.DataFrame({
+            'area': [area],
+            'distance_from_road': [distance_from_road],
+            'income': [income],
+            'land_contour_hilly': [1 if land_contour == 'hilly' else 0],
+            'land_contour_sloping': [1 if land_contour == 'sloping' else 0],
+            'soil_type_clay': [1 if soil_type == 'clay' else 0],
+            'soil_type_sandy': [1 if soil_type == 'sandy' else 0],
+            'soil_type_silty': [1 if soil_type == 'silty' else 0]
+        })
+
+        # Add missing columns with value 0
+        for column in price_model.feature_names_in_:
+            if column not in input_data_price.columns:
+                input_data_price[column] = 0
+
+        # Ensure column order matches training data
+        input_data_price = input_data_price[price_model.feature_names_in_]
+
+        # Predict farm price
+        predicted_price = float(price_model.predict(input_data_price)[0])
+
+        # Determine loan value
+        loan_value = predicted_price if predicted_price <= 500000 else predicted_price * 0.85
+
+        # Calculate loan approval probability
+        if loan_request <= loan_value:
+            approval_probability = 1.0
+        else:
+            diff_ratio = (loan_request - loan_value) / loan_value
+            approval_probability = float(np.exp(-5 * diff_ratio))
+
+        # Return prediction results
+        return jsonify({
+            'success': True,
+            'predicted_price': round(predicted_price, 2),
+            'loan_value': round(loan_value, 2),
+            'approval_probability': round(approval_probability * 100, 2),
+            'loan_request': loan_request,
+            'recommendation': 'Approved' if approval_probability >= 0.5 else 'Denied'
+        }), 200
+
+    except ValueError as e:
+        return jsonify({
+            "error": f"Invalid data type: {str(e)}"
+        }), 400
+    except Exception as e:
+        return jsonify({
+            "error": f"An error occurred: {str(e)}"
+        }), 500
+
+
+# =============================================================================
+# Price Forecasting Endpoint
+# =============================================================================
+
+# Import price forecast module
+try:
+    import sys
+    sys.path.insert(0, os.path.dirname(__file__))
+    from forecast_model import forecast_prices
+    FORECAST_AVAILABLE = True
+except ImportError as e:
+    print(f"Price forecast module not available: {e}")
+    FORECAST_AVAILABLE = False
+
+
+@app.route('/ai/price-forecast', methods=['POST'])
+def price_forecast():
+    """
+    Price forecasting endpoint for commodities
+    
+    Request body:
+    {
+        "historical_prices": [{"date": "2024-01-01", "price": 100, "volume": 1000}, ...],
+        "location": {"lat": 19.0, "lng": 73.0, "state": "Maharashtra"},
+        "commodity_type": "groundnut",
+        "global_indices": {"crude_oil": 80, "soybean": 1200, "usd_inr": 83},
+        "forecast_days": 30
+    }
+    """
+    if not FORECAST_AVAILABLE:
+        return jsonify({
+            "success": False,
+            "error": "Price forecast module not available"
+        }), 503
+    
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                "success": False,
+                "error": "No data provided"
+            }), 400
+        
+        # Validate required fields
+        historical_prices = data.get('historical_prices', [])
+        if not historical_prices or len(historical_prices) < 5:
+            return jsonify({
+                "success": False,
+                "error": "Need at least 5 historical price points"
+            }), 400
+        
+        # Extract optional parameters
+        location = data.get('location')
+        commodity_type = data.get('commodity_type', 'oilseed')
+        global_indices = data.get('global_indices')
+        forecast_days = data.get('forecast_days', 30)
+        
+        # Validate forecast_days
+        if forecast_days not in [7, 30, 90]:
+            forecast_days = 30
+        
+        # Generate forecast
+        result = forecast_prices(
+            historical_prices=historical_prices,
+            location=location,
+            commodity_type=commodity_type,
+            global_indices=global_indices,
+            forecast_days=forecast_days
+        )
+        
+        if result.get('success'):
+            return jsonify(result), 200
+        else:
+            return jsonify(result), 400
+            
+    except ValueError as e:
+        return jsonify({
+            "success": False,
+            "error": f"Invalid data: {str(e)}"
+        }), 400
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": f"Forecast error: {str(e)}"
+        }), 500
+
+
+# =============================================================================
+# Yield Prediction Endpoint
+# =============================================================================
+
+@app.route('/ai/yield-predict', methods=['POST'])
+def yield_prediction():
+    """
+    Yield prediction endpoint
+    
+    Request body:
+    {
+        "crop_type": "groundnut",
+        "location": {"lat": 19.0, "lng": 73.0, "state": "Maharashtra"},
+        "soil_data": {"nitrogen": 50, "phosphorus": 30, "potassium": 40, "ph": 6.5},
+        "weather_data": {"rainfall": 800, "temperature": 28, "humidity": 65},
+        "area_hectares": 5
+    }
+    """
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({
+                "success": False,
+                "error": "No data provided"
+            }), 400
+        
+        crop_type = data.get('crop_type', 'groundnut')
+        location = data.get('location', {})
+        soil_data = data.get('soil_data', {})
+        weather_data = data.get('weather_data', {})
+        area_hectares = data.get('area_hectares', 1)
+        
+        # Simple yield estimation based on factors
+        # In production, this would use a trained ML model
+        
+        # Base yield per hectare (kg/ha) by crop
+        base_yields = {
+            'groundnut': 1800,
+            'sunflower': 1200,
+            'soybean': 2000,
+            'mustard': 1100,
+            'sesame': 600,
+            'castor': 1500,
+            'linseed': 800
+        }
+        
+        base_yield = base_yields.get(crop_type.lower(), 1500)
+        
+        # Adjust for soil quality
+        soil_factor = 1.0
+        if soil_data:
+            n = soil_data.get('nitrogen', 50)
+            p = soil_data.get('phosphorus', 30)
+            k = soil_data.get('potassium', 40)
+            ph = soil_data.get('ph', 6.5)
+            
+            # Optimal ranges adjustment
+            if 40 <= n <= 60 and 25 <= p <= 40 and 30 <= k <= 50:
+                soil_factor = 1.1
+            elif n < 20 or p < 15 or k < 20:
+                soil_factor = 0.8
+            
+            # pH adjustment
+            if 6.0 <= ph <= 7.5:
+                soil_factor *= 1.05
+            elif ph < 5.5 or ph > 8.0:
+                soil_factor *= 0.85
+        
+        # Adjust for weather
+        weather_factor = 1.0
+        if weather_data:
+            rainfall = weather_data.get('rainfall', 700)
+            temp = weather_data.get('temperature', 28)
+            
+            # Rainfall adjustment
+            if 600 <= rainfall <= 1000:
+                weather_factor = 1.1
+            elif rainfall < 400 or rainfall > 1500:
+                weather_factor = 0.75
+            
+            # Temperature adjustment
+            if 25 <= temp <= 32:
+                weather_factor *= 1.05
+            elif temp < 20 or temp > 38:
+                weather_factor *= 0.85
+        
+        # Calculate predicted yield
+        predicted_yield_per_ha = base_yield * soil_factor * weather_factor
+        total_yield = predicted_yield_per_ha * area_hectares
+        
+        # Calculate confidence based on data completeness
+        confidence = 0.7
+        if soil_data:
+            confidence += 0.1
+        if weather_data:
+            confidence += 0.1
+        if location:
+            confidence += 0.05
+        
+        # Generate recommendations
+        interventions = []
+        if soil_factor < 1.0:
+            interventions.append({
+                "type": "fertilization",
+                "priority": "high",
+                "recommendation": "Apply balanced NPK fertilizer to improve soil nutrient levels"
+            })
+        if weather_factor < 1.0:
+            interventions.append({
+                "type": "irrigation",
+                "priority": "medium",
+                "recommendation": "Consider supplemental irrigation during dry spells"
+            })
+        
+        return jsonify({
+            "success": True,
+            "data": {
+                "crop_type": crop_type,
+                "area_hectares": area_hectares,
+                "predicted_yield_kg_per_ha": round(predicted_yield_per_ha, 2),
+                "total_predicted_yield_kg": round(total_yield, 2),
+                "confidence": round(confidence, 2),
+                "factors": {
+                    "soil_factor": round(soil_factor, 2),
+                    "weather_factor": round(weather_factor, 2)
+                },
+                "interventions": interventions,
+                "feature_importance": {
+                    "soil_nutrients": 0.35,
+                    "rainfall": 0.25,
+                    "temperature": 0.15,
+                    "location": 0.15,
+                    "crop_variety": 0.10
+                }
+            }
+        }), 200
+        
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": f"Prediction error: {str(e)}"
+        }), 500
+
+
+# =============================================================================
+# Tariff Impact Simulation Endpoint
+# =============================================================================
+
+@app.route('/ai/tariff-simulate', methods=['POST'])
+def tariff_simulation():
+    """
+    Simulate impact of customs duty changes on imports and prices
+    
+    Request body:
+    {
+        "tariff_pct": 35,
+        "period": "6_months",
+        "global_price_shock": 0
+    }
+    """
+    try:
+        data = request.get_json() or {}
+        
+        tariff_pct = data.get('tariff_pct', 35)
+        period = data.get('period', '6_months')
+        global_price_shock = data.get('global_price_shock', 0)  # % change in global prices
+        
+        # Base parameters (simplified model)
+        base_import_volume = 15000000  # 15 million tonnes
+        base_domestic_price = 120  # INR per kg
+        base_farmer_price = 95
+        base_consumer_price = 145
+        
+        # Elasticities (simplified)
+        import_elasticity = -0.8  # How much imports change with price
+        domestic_price_elasticity = 0.3  # How domestic price changes with reduced imports
+        pass_through_farmer = 0.6  # How much of price change reaches farmers
+        pass_through_consumer = 0.8  # How much reaches consumers
+        
+        # Current tariff baseline
+        current_tariff = 35
+        tariff_change = tariff_pct - current_tariff
+        
+        # Calculate impacts
+        # Higher tariff -> lower imports -> higher domestic prices
+        
+        # Import volume change
+        effective_price_change = (tariff_change / 100) + (global_price_shock / 100)
+        import_volume_change = effective_price_change * import_elasticity * 100
+        new_import_volume = base_import_volume * (1 + import_volume_change / 100)
+        new_import_volume = max(new_import_volume, 0)
+        
+        # Domestic price change
+        supply_reduction = (base_import_volume - new_import_volume) / base_import_volume
+        domestic_price_change = supply_reduction * domestic_price_elasticity * 100
+        new_domestic_price = base_domestic_price * (1 + domestic_price_change / 100)
+        
+        # Farmer and consumer prices
+        farmer_price_change = domestic_price_change * pass_through_farmer
+        consumer_price_change = domestic_price_change * pass_through_consumer
+        
+        new_farmer_price = base_farmer_price * (1 + farmer_price_change / 100)
+        new_consumer_price = base_consumer_price * (1 + consumer_price_change / 100)
+        
+        # Sensitivity analysis
+        sensitivity_table = []
+        for sensitivity_tariff in [25, 30, 35, 40, 45, 50]:
+            sens_change = sensitivity_tariff - current_tariff
+            sens_import_change = (sens_change / 100) * import_elasticity * 100
+            sens_import_vol = base_import_volume * (1 + sens_import_change / 100)
+            sens_supply_red = (base_import_volume - sens_import_vol) / base_import_volume
+            sens_price_change = sens_supply_red * domestic_price_elasticity * 100
+            
+            sensitivity_table.append({
+                "tariff_pct": sensitivity_tariff,
+                "import_volume_mt": round(sens_import_vol / 1000000, 2),
+                "domestic_price_inr": round(base_domestic_price * (1 + sens_price_change / 100), 2),
+                "farmer_price_inr": round(base_farmer_price * (1 + sens_price_change * pass_through_farmer / 100), 2)
+            })
+        
+        return jsonify({
+            "success": True,
+            "data": {
+                "scenario": {
+                    "tariff_pct": tariff_pct,
+                    "period": period,
+                    "global_price_shock_pct": global_price_shock
+                },
+                "baseline": {
+                    "import_volume_mt": round(base_import_volume / 1000000, 2),
+                    "domestic_price_inr_kg": base_domestic_price,
+                    "farmer_price_inr_kg": base_farmer_price,
+                    "consumer_price_inr_kg": base_consumer_price
+                },
+                "predicted": {
+                    "import_volume_mt": round(new_import_volume / 1000000, 2),
+                    "import_change_pct": round(import_volume_change, 2),
+                    "domestic_price_inr_kg": round(new_domestic_price, 2),
+                    "domestic_price_change_pct": round(domestic_price_change, 2),
+                    "farmer_price_inr_kg": round(new_farmer_price, 2),
+                    "farmer_price_change_pct": round(farmer_price_change, 2),
+                    "consumer_price_inr_kg": round(new_consumer_price, 2),
+                    "consumer_price_change_pct": round(consumer_price_change, 2)
+                },
+                "sensitivity_analysis": sensitivity_table,
+                "model_assumptions": {
+                    "import_elasticity": import_elasticity,
+                    "domestic_price_elasticity": domestic_price_elasticity,
+                    "pass_through_farmer": pass_through_farmer,
+                    "pass_through_consumer": pass_through_consumer
+                }
+            }
+        }), 200
+        
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": f"Simulation error: {str(e)}"
+        }), 500
+
+
+# =============================================================================
+# CROPIC - Crop Image Analysis Endpoint
+# =============================================================================
+
+@app.route('/ai/cropic/analyze', methods=['POST'])
+def cropic_analyze():
+    """
+    Analyze crop damage from image for insurance purposes
+    
+    Request: multipart/form-data with:
+    - file: image file
+    - metadata: JSON string with {lat, lng, crop_type, stage}
+    """
+    try:
+        if 'file' not in request.files:
+            return jsonify({
+                "success": False,
+                "error": "No image file provided"
+            }), 400
+        
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({
+                "success": False,
+                "error": "Empty filename"
+            }), 400
+        
+        # Get metadata
+        metadata = {}
+        if 'metadata' in request.form:
+            try:
+                metadata = json.loads(request.form['metadata'])
+            except:
+                pass
+        
+        # Read and validate image
+        img_bytes = file.read()
+        
+        # Load disease model if available (lazy)
+        model = model_manager.get_model('disease_model', auto_load=False)
+        labels = model_manager.get_model('disease_labels', auto_load=False) or []
+        
+        # Check file size (max 10MB)
+        if len(img_bytes) > 10 * 1024 * 1024:
+            return jsonify({
+                "success": False,
+                "error": "Image too large. Maximum size is 10MB"
+            }), 400
+        
+        try:
+            pil_img = Image.open(io.BytesIO(img_bytes))
+            pil_img = pil_img.convert('RGB')
+            
+            # Check image dimensions
+            width, height = pil_img.size
+            if width < 100 or height < 100:
+                return jsonify({
+                    "success": False,
+                    "error": "Image too small. Minimum dimensions: 100x100"
+                }), 400
+                
+        except Exception as e:
+            return jsonify({
+                "success": False,
+                "error": f"Invalid image format: {str(e)}"
+            }), 400
+        
+        # Use existing disease model for classification if available
+        crop_type = metadata.get('crop_type', 'unknown')
+        stage = metadata.get('stage', 'vegetative')
+        
+        # If disease model is loaded, use it for damage classification
+        damage_type = "unknown"
+        damage_percentage = 0
+        confidence = 0.5
+        
+        if model is not None:
+            try:
+                top_label, conf, topk = predict(model, pil_img, labels, device, topk=5)
+                
+                # Map disease labels to damage types
+                damage_mapping = {
+                    'healthy': ('none', 0),
+                    'bacterial': ('bacterial_infection', 40),
+                    'fungal': ('fungal_disease', 35),
+                    'viral': ('viral_infection', 45),
+                    'pest': ('pest_damage', 30),
+                    'nutrient': ('nutrient_deficiency', 25),
+                    'drought': ('drought_stress', 50),
+                    'flood': ('waterlogging', 60)
+                }
+                
+                # Simple matching
+                for key, (dtype, dpct) in damage_mapping.items():
+                    if key in top_label.lower():
+                        damage_type = dtype
+                        damage_percentage = dpct
+                        break
+                
+                if 'healthy' in top_label.lower():
+                    damage_type = 'none'
+                    damage_percentage = 0
+                else:
+                    # Estimate damage from confidence
+                    damage_percentage = int(conf * 50)  # Scale to reasonable range
+                    if damage_type == 'unknown':
+                        damage_type = 'unclassified_damage'
+                
+                confidence = float(conf)
+                
+            except Exception as e:
+                print(f"Classification error: {e}")
+                # Fallback to random estimation for demo
+                damage_type = "unclassified_damage"
+                damage_percentage = np.random.randint(10, 50)
+                confidence = 0.6
+        else:
+            # No model - provide simulated response
+            damage_types = ['none', 'pest_damage', 'disease', 'drought_stress', 'flood_damage']
+            damage_type = np.random.choice(damage_types, p=[0.3, 0.2, 0.25, 0.15, 0.1])
+            damage_percentage = 0 if damage_type == 'none' else np.random.randint(10, 60)
+            confidence = np.random.uniform(0.6, 0.9)
+        
+        return jsonify({
+            "success": True,
+            "data": {
+                "crop_type": crop_type,
+                "stage": stage,
+                "damage_type": damage_type,
+                "damage_percentage": damage_percentage,
+                "confidence": round(confidence, 2),
+                "image_quality": {
+                    "dimensions": f"{width}x{height}",
+                    "format": pil_img.format or "JPEG",
+                    "is_valid": True
+                },
+                "location": {
+                    "lat": metadata.get('lat'),
+                    "lng": metadata.get('lng')
+                },
+                "recommendations": _get_damage_recommendations(damage_type, damage_percentage)
+            }
+        }), 200
+        
+    except Exception as e:
+        return jsonify({
+            "success": False,
+            "error": f"Analysis error: {str(e)}"
+        }), 500
+
+
+def _get_damage_recommendations(damage_type: str, damage_pct: int) -> list:
+    """Get recommendations based on damage type and severity"""
+    recommendations = []
+    
+    if damage_type == 'none':
+        recommendations.append({
+            "action": "monitoring",
+            "description": "Continue regular monitoring. Crop appears healthy."
+        })
+    elif damage_type == 'pest_damage':
+        recommendations.append({
+            "action": "pesticide_application",
+            "description": "Apply appropriate pesticide. Consult local agriculture office for specific recommendations."
+        })
+    elif damage_type in ['disease', 'bacterial_infection', 'fungal_disease']:
+        recommendations.append({
+            "action": "fungicide_treatment",
+            "description": "Apply fungicide treatment. Remove and destroy affected plant parts."
+        })
+    elif damage_type == 'drought_stress':
+        recommendations.append({
+            "action": "irrigation",
+            "description": "Increase irrigation frequency. Apply mulch to retain soil moisture."
+        })
+    elif damage_type in ['flood_damage', 'waterlogging']:
+        recommendations.append({
+            "action": "drainage",
+            "description": "Improve field drainage. Allow soil to dry before resuming irrigation."
+        })
+    
+    if damage_pct >= 50:
+        recommendations.append({
+            "action": "insurance_claim",
+            "description": "Damage exceeds 50%. Consider filing an insurance claim.",
+            "priority": "high"
+        })
+    
+    return recommendations
+
+
+# ── Harvest Readiness Detection ─────────────────────────────────────────────
+_harvest_model = None
+
+def _load_harvest_model():
+    """Lazy-load the harvest readiness YOLO classification model from HF Hub."""
+    global _harvest_model
+    if _harvest_model is not None:
+        return _harvest_model
+    try:
+        from ultralytics import YOLO
+        model_path = hf_hub_download(
+            repo_id=HF_REPO_HARVEST, filename="best.pt"
+        )
+        _harvest_model = YOLO(model_path)
+        logger.info("Harvest readiness YOLO model loaded from HF Hub")
+    except Exception as e:
+        log_exception(logger, e, "Failed to load harvest readiness model")
+        _harvest_model = None
+    return _harvest_model
+
+
+@app.route("/harvest_readiness", methods=["POST"])
+def harvest_readiness():
+    """Detect harvest readiness from a crop image using YOLO11m-cls."""
+    model = _load_harvest_model()
+    if model is None:
+        return jsonify({"error": "Harvest readiness model unavailable"}), 503
+
+    if "file" not in request.files:
+        return jsonify({"error": "no file part"}), 400
+    file = request.files["file"]
+    if file.filename == "":
+        return jsonify({"error": "empty filename"}), 400
+
+    try:
+        img_bytes = file.read()
+        pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+
+        results = model.predict(pil_img, imgsz=224, verbose=False)
+        result = results[0]
+
+        # Classification results: result.probs contains probabilities
+        probs = result.probs
+        top_class_idx = int(probs.top1)
+        top_confidence = float(probs.top1conf)
+        class_name = result.names[top_class_idx] if result.names else str(top_class_idx)
+
+        # Determine readiness from class name using keyword matching
+        # The YOLO model classifies into categories like "Ready", "Unripe", "Overripe", etc.
+        ready_keywords = {"ready", "ripe", "mature", "harvest", "overripe"}
+        unready_keywords = {"unready", "unripe", "immature", "green", "growing"}
+        class_lower = class_name.lower()
+        class_tokens = set(class_lower.replace("_", " ").replace("-", " ").split())
+        is_ready = bool(class_tokens & ready_keywords) and not bool(class_tokens & unready_keywords)
+
+        # Estimate maturity percentage from confidence and class
+        if is_ready:
+            maturity = max(80, int(top_confidence * 100))
+            days_left = 0
+        else:
+            maturity = max(10, min(70, int(top_confidence * 60)))
+            days_left = max(1, int((100 - maturity) * 0.5))
+
+        # Build top-k predictions
+        topk_indices = probs.top5 if hasattr(probs, 'top5') else [top_class_idx]
+        topk_confs = probs.top5conf.tolist() if hasattr(probs, 'top5conf') else [top_confidence]
+        topk = [
+            {"label": result.names.get(int(idx), str(idx)), "confidence": round(float(c), 4)}
+            for idx, c in zip(topk_indices, topk_confs)
+        ]
+
+        return jsonify({
+            "ready": "Yes" if is_ready else "No",
+            "maturity": maturity,
+            "days_left": days_left,
+            "note": f"Classified as '{class_name}' with {top_confidence:.1%} confidence.",
+            "class": class_name,
+            "confidence": round(top_confidence, 4),
+            "topk": topk,
+        })
+    except Exception as e:
+        logger.error(f"Harvest readiness prediction error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+# ── Saffron Authenticity Classifier ──────────────────────────────────────────
+HF_SAFFRON_REPO = os.environ.get("HF_REPO_SAFFRON", "Arko007/saffron-verify-pretrained")
+HF_SAFFRON_API = f"https://api-inference.huggingface.co/models/{HF_SAFFRON_REPO}"
+SAFFRON_CLASSES = ["mogra", "lacha", "adulterated"]
+
+
+@app.route("/saffron_classify", methods=["POST"])
+def saffron_classify():
+    """Classify saffron purity from an uploaded image."""
+    if "file" not in request.files:
+        return jsonify({"error": "no file part"}), 400
+    file = request.files["file"]
+    if file.filename == "":
+        return jsonify({"error": "empty filename"}), 400
+
+    try:
+        img_bytes = file.read()
+        # Validate it is a real image
+        pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+
+        # Try HF Inference API first
+        hf_token = os.environ.get("HF_TOKEN", "")
+        headers = {}
+        if hf_token:
+            headers["Authorization"] = f"Bearer {hf_token}"
+
+        try:
+            # Re-encode as JPEG for the API
+            buf = io.BytesIO()
+            pil_img.save(buf, format="JPEG")
+            resp = _call_hf_inference_api(
+                HF_SAFFRON_API,
+                headers=headers,
+                data=buf.getvalue(),
+            )
+            if resp.status_code == 200:
+                results = resp.json()
+                if isinstance(results, list) and len(results) > 0:
+                    top = results[0]
+                    return jsonify({
+                        "model": "saffron-verify-pretrained",
+                        "prediction": top.get("label", "unknown"),
+                        "confidence": round(top.get("score", 0.0), 4),
+                        "all_predictions": [
+                            {"label": r.get("label", ""), "confidence": round(r.get("score", 0.0), 4)}
+                            for r in results
+                        ],
+                        "timestamp": _time.strftime("%Y-%m-%dT%H:%M:%SZ", _time.gmtime()),
+                    })
+            logger.warning(f"Saffron HF API returned status {resp.status_code}: {resp.text[:200]}")
+        except Exception as api_err:
+            logger.warning(f"Saffron HF Inference API failed: {api_err}")
+
+        # Fallback: try loading model locally via timm
+        try:
+            import timm
+            import torch.nn as nn
+            from torchvision import transforms
+
+            class _SaffronModel(nn.Module):
+                def __init__(self):
+                    super().__init__()
+                    self.backbone = timm.create_model(
+                        "convnext_base", pretrained=False,
+                        num_classes=0, drop_rate=0.3, drop_path_rate=0.2,
+                    )
+                    feat_dim = self.backbone.num_features
+                    self.head = nn.Sequential(
+                        nn.LayerNorm(feat_dim),
+                        nn.Dropout(p=0.3),
+                        nn.Linear(feat_dim, 512),
+                        nn.GELU(),
+                        nn.Dropout(p=0.15),
+                        nn.Linear(512, 3),
+                    )
+
+                def forward(self, x):
+                    return self.head(self.backbone(x))
+
+            ckpt_path = hf_hub_download(repo_id=HF_SAFFRON_REPO, filename="best_model.pth")
+            model_s = _SaffronModel()
+            ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+            model_s.load_state_dict(ckpt.get("model_state", ckpt.get("model_state_dict", ckpt)))
+            model_s.eval()
+
+            transform = transforms.Compose([
+                transforms.Resize(512),
+                transforms.CenterCrop(512),
+                transforms.ToTensor(),
+                transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+            ])
+            tensor = transform(pil_img).unsqueeze(0)
+            with torch.no_grad():
+                logits = model_s(tensor)
+                probs = torch.softmax(logits, dim=1)[0]
+                pred_idx = probs.argmax().item()
+
+            all_preds = [
+                {"label": SAFFRON_CLASSES[i], "confidence": round(probs[i].item(), 4)}
+                for i in range(len(SAFFRON_CLASSES))
+            ]
+            all_preds.sort(key=lambda x: x["confidence"], reverse=True)
+
+            return jsonify({
+                "model": "saffron-verify-pretrained",
+                "prediction": SAFFRON_CLASSES[pred_idx],
+                "confidence": round(probs[pred_idx].item(), 4),
+                "all_predictions": all_preds,
+                "timestamp": _time.strftime("%Y-%m-%dT%H:%M:%SZ", _time.gmtime()),
+            })
+        except Exception as local_err:
+            logger.warning(f"Saffron local model also failed: {local_err}")
+
+        return jsonify({"error": "Saffron model unavailable via API and local fallback"}), 503
+    except Exception as e:
+        logger.error(f"Saffron classification error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+# ── Walnut Defect Classifier ────────────────────────────────────────────────
+HF_WALNUT_DEFECT_REPO = os.environ.get("HF_REPO_WALNUT_DEFECT", "Arko007/walnut-defect-classifier")
+HF_WALNUT_DEFECT_API = f"https://api-inference.huggingface.co/models/{HF_WALNUT_DEFECT_REPO}"
+WALNUT_DEFECT_CLASSES = ["Healthy", "Black Spot", "Shriveled", "Damaged"]
+
+
+@app.route("/walnut_defect_classify", methods=["POST"])
+def walnut_defect_classify():
+    """Classify walnut shell defects from an uploaded image."""
+    if "file" not in request.files:
+        return jsonify({"error": "no file part"}), 400
+    file = request.files["file"]
+    if file.filename == "":
+        return jsonify({"error": "empty filename"}), 400
+
+    try:
+        img_bytes = file.read()
+        pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+
+        hf_token = os.environ.get("HF_TOKEN", "")
+        headers = {}
+        if hf_token:
+            headers["Authorization"] = f"Bearer {hf_token}"
+
+        try:
+            buf = io.BytesIO()
+            pil_img.save(buf, format="JPEG")
+            resp = _call_hf_inference_api(
+                HF_WALNUT_DEFECT_API,
+                headers=headers,
+                data=buf.getvalue(),
+            )
+            if resp.status_code == 200:
+                results = resp.json()
+                if isinstance(results, list) and len(results) > 0:
+                    top = results[0]
+                    return jsonify({
+                        "model": "walnut-defect-classifier",
+                        "prediction": top.get("label", "unknown"),
+                        "confidence": round(top.get("score", 0.0), 4),
+                        "all_predictions": [
+                            {"label": r.get("label", ""), "confidence": round(r.get("score", 0.0), 4)}
+                            for r in results
+                        ],
+                        "timestamp": _time.strftime("%Y-%m-%dT%H:%M:%SZ", _time.gmtime()),
+                    })
+            logger.warning(f"Walnut defect HF API returned status {resp.status_code}: {resp.text[:200]}")
+        except Exception as api_err:
+            logger.warning(f"Walnut defect HF Inference API failed: {api_err}")
+
+        # Fallback: load model locally via timm
+        try:
+            import timm
+            ckpt_path = hf_hub_download(repo_id=HF_WALNUT_DEFECT_REPO, filename="best_model.pth")
+            model_w = timm.create_model("efficientnet_b3", pretrained=False, num_classes=4, drop_rate=0.4)
+            ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+            state = {k.replace("module.", ""): v for k, v in ckpt.get("model_state_dict", ckpt).items()}
+            model_w.load_state_dict(state)
+            model_w.eval()
+
+            from torchvision import transforms
+            transform = transforms.Compose([
+                transforms.Resize((512, 512)),
+                transforms.ToTensor(),
+                transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+            ])
+            tensor = transform(pil_img).unsqueeze(0)
+            with torch.no_grad():
+                probs = torch.softmax(model_w(tensor), dim=1)[0]
+                pred_idx = probs.argmax().item()
+
+            all_preds = [
+                {"label": WALNUT_DEFECT_CLASSES[i], "confidence": round(probs[i].item(), 4)}
+                for i in range(len(WALNUT_DEFECT_CLASSES))
+            ]
+            all_preds.sort(key=lambda x: x["confidence"], reverse=True)
+
+            return jsonify({
+                "model": "walnut-defect-classifier",
+                "prediction": WALNUT_DEFECT_CLASSES[pred_idx],
+                "confidence": round(probs[pred_idx].item(), 4),
+                "all_predictions": all_preds,
+                "timestamp": _time.strftime("%Y-%m-%dT%H:%M:%SZ", _time.gmtime()),
+            })
+        except Exception as local_err:
+            logger.warning(f"Walnut defect local model also failed: {local_err}")
+
+        return jsonify({"error": "Walnut defect model unavailable via API and local fallback"}), 503
+    except Exception as e:
+        logger.error(f"Walnut defect classification error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+# ── Walnut Rancidity Predictor ──────────────────────────────────────────────
+
+@app.route("/walnut_rancidity_predict", methods=["POST"])
+def walnut_rancidity_predict():
+    """Predict walnut rancidity and remaining shelf life from storage conditions.
+
+    Uses Arrhenius-based lipid oxidation kinetics (the same chemistry model
+    behind the Arko007/walnut-rancidity-predictor HF model) so that the
+    endpoint works without downloading a ~85 K-parameter LSTM checkpoint.
+    """
+    is_valid, error_response = validate_content_type(request)
+    if not is_valid:
+        return jsonify(error_response), error_response["status"]
+
+    try:
+        data = request.get_json(force=True)
+    except Exception:
+        return jsonify({"error": "Invalid JSON payload"}), 400
+
+    # Required fields
+    storage_days = data.get("storage_days")
+    temperature = data.get("temperature")
+    humidity = data.get("humidity")
+    moisture = data.get("moisture")
+
+    if storage_days is None or temperature is None or humidity is None or moisture is None:
+        return jsonify({
+            "error": "Missing required fields: storage_days, temperature, humidity, moisture"
+        }), 400
+
+    try:
+        storage_days = float(storage_days)
+        temperature = float(temperature)
+        humidity = float(humidity)
+        moisture = float(moisture)
+    except (ValueError, TypeError):
+        return jsonify({"error": "All inputs must be numeric"}), 400
+
+    # Validation with friendly responses
+    if storage_days < 0 or storage_days > 365:
+        return jsonify({
+            "success": False,
+            "message": "Please choose storage days between 0 and 365 days.",
+            "validation_error": "storage_days_out_of_range"
+        }), 200
+    
+    if temperature < -10 or temperature > 50:
+        return jsonify({
+            "success": False,
+            "message": "Please choose temperature between -10 and 50 degrees Celsius.",
+            "validation_error": "temperature_out_of_range"
+        }), 200
+    
+    if humidity < 0 or humidity > 100:
+        return jsonify({
+            "success": False,
+            "message": "Please choose humidity between 0 and 100 percent.",
+            "validation_error": "humidity_out_of_range"
+        }), 200
+    
+    if moisture < 0 or moisture > 15:
+        return jsonify({
+            "success": False,
+            "message": "Please choose a value between 0 and 15 percent for moisture content.",
+            "validation_error": "moisture_out_of_range"
+        }), 200
+
+    try:
+        import math
+
+        # Arrhenius kinetics: k(T) = A * exp(-Ea / (R * T_kelvin))
+        A = 1.5e12
+        Ea = 80_000  # J/mol
+        R = 8.314    # J/(mol*K)
+        T_kelvin = temperature + 273.15
+        k_base = A * math.exp(-Ea / (R * T_kelvin))
+
+        # Humidity and moisture correction factors
+        humidity_factor = 1.0 + 0.005 * max(0, humidity - 50)
+        moisture_factor = 1.0 + 0.02 * max(0, moisture - 4)
+        k_eff = k_base * humidity_factor * moisture_factor
+
+        # PV(t) = PV_0 * exp(k * t)  — initial PV ~ 0.5 meq/kg for fresh walnuts
+        PV_0 = 0.5
+        PV_t = PV_0 * math.exp(k_eff * storage_days)
+
+        # Rancidity threshold: PV > 5 meq/kg (FSSAI / Codex)
+        rancidity_prob = 1.0 / (1.0 + math.exp(-(PV_t - 5)))
+
+        # Shelf life remaining = days until PV reaches 5
+        if PV_t >= 5:
+            shelf_life_remaining = 0.0
+        elif k_eff > 0:
+            shelf_life_remaining = max(0.0, (math.log(5 / PV_0) / k_eff) - storage_days)
+        else:
+            shelf_life_remaining = 365.0
+
+        # Decay curve (normalised PV, capped at 1)
+        decay_curve = min(1.0, PV_t / 10.0)
+
+        # Risk level
+        if rancidity_prob < 0.30:
+            risk_level = "LOW"
+        elif rancidity_prob < 0.70:
+            risk_level = "MEDIUM"
+        else:
+            risk_level = "HIGH"
+
+        return jsonify({
+            "success": True,
+            "model": "walnut-rancidity-predictor",
+            "prediction": {
+                "rancidity_probability": round(rancidity_prob, 4),
+                "shelf_life_remaining_days": round(shelf_life_remaining, 1),
+                "decay_curve_value": round(decay_curve, 4),
+            },
+            "risk_level": risk_level,
+            "advisory": (
+                "Walnuts are safe for storage."
+                if risk_level == "LOW"
+                else "Monitor quality closely — consider selling soon."
+                if risk_level == "MEDIUM"
+                else "High rancidity risk — sell or consume immediately."
+            ),
+            "timestamp": _time.strftime("%Y-%m-%dT%H:%M:%SZ", _time.gmtime()),
+        }), 200
+    except Exception as e:
+        logger.error(f"Walnut rancidity prediction error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+# ── Apple Price Predictor ────────────────────────────────────────────────────
+APPLE_VARIETY_BASE_PRICES = {
+    "Shimla": 97, "Kinnauri": 125, "Royal Delicious": 82,
+    "Golden Delicious": 87, "Maharaji": 60,
+}
+APPLE_REGIONS = ["Himachal Pradesh", "Jammu & Kashmir", "Uttarakhand",
+                 "Arunachal Pradesh", "Nagaland"]
+APPLE_STORAGE_COST_PER_DAY = 0.75  # ₹/kg/day
+
+
+@app.route("/apple_price_predict", methods=["POST"])
+def apple_price_predict():
+    """Predict apple wholesale price 7 days ahead and recommend SELL or STORE."""
+    is_valid, error_response = validate_content_type(request)
+    if not is_valid:
+        return jsonify(error_response), error_response["status"]
+
+    try:
+        data = request.get_json(force=True)
+    except Exception:
+        return jsonify({"error": "Invalid JSON payload"}), 400
+
+    current_price = data.get("current_price")
+    apple_variety = data.get("apple_variety", "Shimla")
+    region = data.get("region", "Himachal Pradesh")
+    storage_time_days = data.get("storage_time_days", 0)
+    date_str = data.get("date", _time.strftime("%Y-%m-%d"))
+
+    if current_price is None:
+        return jsonify({"error": "current_price is required"}), 400
+
+    try:
+        current_price = float(current_price)
+        storage_time_days = int(storage_time_days)
+    except (ValueError, TypeError):
+        return jsonify({"error": "current_price must be numeric, storage_time_days must be integer"}), 400
+
+    if current_price <= 0:
+        return jsonify({"error": "current_price must be positive"}), 400
+
+    try:
+        import math
+        from datetime import datetime
+
+        # Parse date for seasonal adjustment
+        try:
+            dt = datetime.strptime(date_str, "%Y-%m-%d")
+        except ValueError:
+            dt = datetime.utcnow()
+
+        month = dt.month
+
+        # Seasonal price adjustments (Indian apple market dynamics)
+        seasonal_adj = 0.0
+        if 7 <= month <= 9:        # Harvest season — supply glut
+            seasonal_adj = -12.0
+        elif 4 <= month <= 6:      # Summer scarcity
+            seasonal_adj = 15.0
+        elif month in (10, 11):    # Diwali festival demand
+            seasonal_adj = 8.0
+
+        # Variety premium
+        base_price = APPLE_VARIETY_BASE_PRICES.get(apple_variety, 90)
+        variety_factor = base_price / 90.0
+
+        # Storage quality decay
+        storage_decay = -0.08 * storage_time_days
+
+        # Simple trend: mild inflation
+        annual_inflation = 5.0
+        days_in_year = 365.0
+        trend_adj = (7.0 / days_in_year) * annual_inflation
+
+        # Predicted 7-day price (deterministic)
+        predicted_price_7d = round(
+            current_price * variety_factor
+            + seasonal_adj
+            + storage_decay
+            + trend_adj,
+            2,
+        )
+        # Clamp to realistic range
+        predicted_price_7d = max(30.0, min(200.0, predicted_price_7d))
+
+        storage_cost_7d = round(APPLE_STORAGE_COST_PER_DAY * 7, 2)
+        breakeven_price = round(current_price + storage_cost_7d, 2)
+        recommendation = "STORE" if predicted_price_7d > breakeven_price else "SELL"
+
+        return jsonify({
+            "model": "apple-price-predictor",
+            "predicted_price_7d": predicted_price_7d,
+            "recommendation": recommendation,
+            "current_price": current_price,
+            "storage_cost_7d": storage_cost_7d,
+            "breakeven_price": breakeven_price,
+            "currency": "INR",
+            "confidence": "hybrid seasonal+trend model",
+            "advisory": (
+                f"Predicted price in 7 days: ₹{predicted_price_7d}/kg. "
+                f"{'Store for better returns.' if recommendation == 'STORE' else 'Sell now — prices may not cover storage costs.'}"
+            ),
+            "timestamp": _time.strftime("%Y-%m-%dT%H:%M:%SZ", _time.gmtime()),
+        }), 200
+    except Exception as e:
+        logger.error(f"Apple price prediction error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=5000, debug=True)

ai-backend/forecast_model.py

@@ -0,0 +1,354 @@
+"""
+Price Forecasting Module for AgroMind AI Backend
+Uses LightGBM for time-series price prediction with confidence intervals
+"""
+import os
+import json
+import pickle
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple, Any
+
+import numpy as np
+import pandas as pd
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+import lightgbm as lgb
+
+
+class PriceForecastModel:
+    """
+    Price forecasting model using LightGBM
+    """
+    
+    def __init__(self):
+        self.model = None
+        self.scaler = None
+        self.feature_names = None
+        self.is_trained = False
+        self._load_model()
+    
+    def _load_model(self):
+        """Load pre-trained model if available (currently no pre-trained
+        price forecast model is shipped)."""
+        self.model = None
+        self.scaler = None
+        self.is_trained = False
+    
+    def prepare_features(
+        self,
+        historical_prices: List[Dict],
+        location: Optional[Dict] = None,
+        commodity_type: str = "oilseed",
+        global_indices: Optional[Dict] = None
+    ) -> Tuple[np.ndarray, List[str]]:
+        """
+        Prepare features for price forecasting
+        
+        Args:
+            historical_prices: List of {date, price, volume} dicts
+            location: {lat, lng, state, district}
+            commodity_type: Type of commodity
+            global_indices: Optional global market indices
+        
+        Returns:
+            Feature array and feature names
+        """
+        df = pd.DataFrame(historical_prices)
+        
+        if 'date' in df.columns:
+            df['date'] = pd.to_datetime(df['date'])
+            df = df.sort_values('date')
+        
+        features = {}
+        feature_names = []
+        
+        # Price-based features
+        if 'price' in df.columns:
+            prices = df['price'].values
+            
+            # Basic statistics
+            features['price_mean'] = np.mean(prices)
+            features['price_std'] = np.std(prices)
+            features['price_min'] = np.min(prices)
+            features['price_max'] = np.max(prices)
+            features['price_last'] = prices[-1] if len(prices) > 0 else 0
+            
+            # Trend features
+            if len(prices) >= 7:
+                features['price_ma_7'] = np.mean(prices[-7:])
+            else:
+                features['price_ma_7'] = features['price_mean']
+            
+            if len(prices) >= 30:
+                features['price_ma_30'] = np.mean(prices[-30:])
+            else:
+                features['price_ma_30'] = features['price_mean']
+            
+            # Volatility
+            if len(prices) >= 2:
+                returns = np.diff(prices) / prices[:-1]
+                features['volatility'] = np.std(returns) if len(returns) > 0 else 0
+            else:
+                features['volatility'] = 0
+            
+            # Momentum
+            if len(prices) >= 7:
+                features['momentum_7d'] = (prices[-1] - prices[-7]) / prices[-7] if prices[-7] != 0 else 0
+            else:
+                features['momentum_7d'] = 0
+            
+            feature_names.extend([
+                'price_mean', 'price_std', 'price_min', 'price_max', 
+                'price_last', 'price_ma_7', 'price_ma_30', 
+                'volatility', 'momentum_7d'
+            ])
+        
+        # Volume features
+        if 'volume' in df.columns:
+            volumes = df['volume'].values
+            features['volume_mean'] = np.mean(volumes)
+            features['volume_last'] = volumes[-1] if len(volumes) > 0 else 0
+            feature_names.extend(['volume_mean', 'volume_last'])
+        
+        # Temporal features
+        if 'date' in df.columns and len(df) > 0:
+            last_date = df['date'].iloc[-1]
+            features['month'] = last_date.month
+            features['quarter'] = (last_date.month - 1) // 3 + 1
+            features['is_harvest_season'] = 1 if last_date.month in [10, 11, 12, 1, 2, 3] else 0
+            feature_names.extend(['month', 'quarter', 'is_harvest_season'])
+        
+        # Location features (encoded)
+        if location:
+            # Simple state encoding (can be expanded)
+            state_codes = {
+                'maharashtra': 1, 'gujarat': 2, 'rajasthan': 3, 
+                'madhya pradesh': 4, 'karnataka': 5, 'andhra pradesh': 6,
+                'telangana': 7, 'tamil nadu': 8, 'punjab': 9, 'haryana': 10
+            }
+            state = location.get('state', '').lower()
+            features['state_code'] = state_codes.get(state, 0)
+            feature_names.append('state_code')
+        
+        # Commodity type encoding
+        commodity_codes = {
+            'groundnut': 1, 'sunflower': 2, 'soybean': 3, 'mustard': 4,
+            'sesame': 5, 'oilseed_meal': 6, 'oilseed_cake': 7, 'oilseed_husk': 8,
+            'castor': 9, 'linseed': 10, 'oilseed': 0
+        }
+        features['commodity_code'] = commodity_codes.get(commodity_type.lower(), 0)
+        feature_names.append('commodity_code')
+        
+        # Global indices
+        if global_indices:
+            features['global_oil_price'] = global_indices.get('crude_oil', 0)
+            features['global_soy_price'] = global_indices.get('soybean', 0)
+            features['usd_inr'] = global_indices.get('usd_inr', 83.0)
+            feature_names.extend(['global_oil_price', 'global_soy_price', 'usd_inr'])
+        
+        # Create feature array
+        feature_array = np.array([features.get(f, 0) for f in feature_names]).reshape(1, -1)
+        
+        return feature_array, feature_names
+    
+    def forecast(
+        self,
+        historical_prices: List[Dict],
+        location: Optional[Dict] = None,
+        commodity_type: str = "oilseed",
+        global_indices: Optional[Dict] = None,
+        forecast_days: int = 30
+    ) -> Dict[str, Any]:
+        """
+        Generate price forecast with confidence intervals
+        
+        Args:
+            historical_prices: List of {date, price, volume} dicts
+            location: Location dict
+            commodity_type: Type of commodity
+            global_indices: Global market indices
+            forecast_days: Number of days to forecast
+        
+        Returns:
+            Forecast results with predictions and confidence intervals
+        """
+        if not historical_prices or len(historical_prices) < 5:
+            return {
+                "success": False,
+                "error": "Insufficient historical data. Need at least 5 price points."
+            }
+        
+        try:
+            # Prepare features
+            features, feature_names = self.prepare_features(
+                historical_prices, location, commodity_type, global_indices
+            )
+            
+            # Get last price for baseline
+            df = pd.DataFrame(historical_prices)
+            df['date'] = pd.to_datetime(df['date'])
+            df = df.sort_values('date')
+            last_price = float(df['price'].iloc[-1])
+            last_date = df['date'].iloc[-1]
+            
+            # Calculate historical volatility for confidence intervals
+            prices = df['price'].values
+            if len(prices) >= 2:
+                returns = np.diff(prices) / prices[:-1]
+                daily_volatility = np.std(returns) if len(returns) > 0 else 0.02
+            else:
+                daily_volatility = 0.02
+            
+            # Generate forecasts
+            forecasts = []
+            
+            if self.model is not None and self.is_trained:
+                # Use trained model
+                for day in range(1, forecast_days + 1):
+                    # This is simplified - in production, would update features iteratively
+                    pred = self.model.predict(features)[0]
+                    forecasts.append(pred)
+            else:
+                # Statistical fallback using trend extrapolation and seasonal adjustment.
+                # Each day's forecast builds on the previous day (random walk with drift),
+                # which is standard for short-horizon price forecasting.
+                logger.info("Using statistical fallback for price forecast (no trained model)")
+                trend = 0.0
+                if len(prices) >= 2:
+                    daily_changes = np.diff(prices)
+                    trend = np.mean(daily_changes)
+
+                current_price = last_price
+                for day in range(1, forecast_days + 1):
+                    forecast_date = last_date + timedelta(days=day)
+                    seasonal = self._get_seasonal_factor(forecast_date.month)
+                    # Monthly seasonal factor scaled to a daily effect
+                    daily_seasonal = current_price * seasonal / 30
+                    pred = current_price + trend + daily_seasonal
+                    pred = max(pred, 0)
+                    forecasts.append(pred)
+                    current_price = pred
+            
+            # Calculate confidence intervals
+            forecast_dates = []
+            predictions = []
+            lower_bounds = []
+            upper_bounds = []
+            
+            for day, pred in enumerate(forecasts, 1):
+                forecast_date = last_date + timedelta(days=day)
+                forecast_dates.append(forecast_date.strftime('%Y-%m-%d'))
+                predictions.append(round(pred, 2))
+                
+                # CI widens with forecast horizon
+                ci_width = daily_volatility * last_price * np.sqrt(day) * 1.96
+                lower_bounds.append(round(max(pred - ci_width, 0), 2))
+                upper_bounds.append(round(pred + ci_width, 2))
+            
+            # Summary statistics
+            avg_forecast = np.mean(predictions)
+            forecast_change = ((predictions[-1] - last_price) / last_price) * 100
+            
+            return {
+                "success": True,
+                "data": {
+                    "commodity": commodity_type,
+                    "location": location,
+                    "last_price": round(last_price, 2),
+                    "last_date": last_date.strftime('%Y-%m-%d'),
+                    "forecast_period_days": forecast_days,
+                    "forecasts": [
+                        {
+                            "date": date,
+                            "predicted_price": pred,
+                            "lower_bound": lb,
+                            "upper_bound": ub,
+                            "confidence_level": 0.95
+                        }
+                        for date, pred, lb, ub in zip(
+                            forecast_dates, predictions, lower_bounds, upper_bounds
+                        )
+                    ],
+                    "summary": {
+                        "average_forecast": round(avg_forecast, 2),
+                        "forecast_change_percent": round(forecast_change, 2),
+                        "trend": "bullish" if forecast_change > 2 else "bearish" if forecast_change < -2 else "neutral",
+                        "volatility": round(daily_volatility * 100, 2),
+                        "model_type": "lightgbm" if self.is_trained else "statistical"
+                    },
+                    "feature_importance": self._get_feature_importance(feature_names) if self.is_trained else None
+                }
+            }
+            
+        except Exception as e:
+            logger.error(f"Forecast error: {e}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def _get_seasonal_factor(self, month: int) -> float:
+        """Get seasonal adjustment factor based on month"""
+        # Oilseed prices typically higher during off-season
+        seasonal_factors = {
+            1: 0.02, 2: 0.03, 3: 0.02, 4: 0.01,  # Post-harvest
+            5: 0.02, 6: 0.03, 7: 0.04, 8: 0.05,  # Pre-harvest (higher)
+            9: 0.03, 10: -0.02, 11: -0.03, 12: -0.02  # Harvest (lower)
+        }
+        return seasonal_factors.get(month, 0)
+    
+    def _get_feature_importance(self, feature_names: List[str]) -> Dict[str, float]:
+        """Get feature importance from trained model"""
+        if self.model is None or not hasattr(self.model, 'feature_importances_'):
+            return None
+        
+        importances = self.model.feature_importances_
+        return {
+            name: round(float(imp), 4) 
+            for name, imp in zip(feature_names, importances)
+        }
+
+
+# Global model instance
+_forecast_model = None
+
+def get_forecast_model() -> PriceForecastModel:
+    """Get or create the price forecast model instance"""
+    global _forecast_model
+    if _forecast_model is None:
+        _forecast_model = PriceForecastModel()
+    return _forecast_model
+
+
+def forecast_prices(
+    historical_prices: List[Dict],
+    location: Optional[Dict] = None,
+    commodity_type: str = "oilseed",
+    global_indices: Optional[Dict] = None,
+    forecast_days: int = 30
+) -> Dict[str, Any]:
+    """
+    Main entry point for price forecasting
+    
+    Args:
+        historical_prices: List of {date, price, volume} dicts
+        location: {lat, lng, state, district}
+        commodity_type: Type of commodity
+        global_indices: Global market indices
+        forecast_days: Number of days to forecast (7, 30, or 90)
+    
+    Returns:
+        Forecast results with predictions and confidence intervals
+    """
+    model = get_forecast_model()
+    return model.forecast(
+        historical_prices=historical_prices,
+        location=location,
+        commodity_type=commodity_type,
+        global_indices=global_indices,
+        forecast_days=forecast_days
+    )

ai-backend/model_utils.py

@@ -0,0 +1,169 @@
+"""model_utils.py
+
+Utilities for loading the image classifier and running inference.
+Downloads model weights from Hugging Face Hub at runtime.
+Supports the NFNet-F1 (safetensors) and MobileNetV2 (.pth) flows.
+"""
+
+import os
+import json
+import logging
+
+import torch
+import torch.nn.functional as F
+from torchvision import models, transforms
+from PIL import Image
+from huggingface_hub import hf_hub_download
+
+logger = logging.getLogger(__name__)
+
+# HF repo identifiers
+HF_REPO_NFNET = os.environ.get(
+    "HF_REPO_NFNET", "Arko007/nfnet-f1-plant-disease"
+)
+
+# Default assumptions (can be overridden by model config.json)
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD = [0.229, 0.224, 0.225]
+INPUT_SIZE = 224
+
+# Preprocessing transform (resize -> center crop -> to tensor -> normalize)
+transform = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(INPUT_SIZE),
+    transforms.ToTensor(),
+    transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD)
+])
+
+
+def _download(repo_id, filename):
+    """Download a file from HF Hub with caching."""
+    logger.info("Downloading %s from %s ...", filename, repo_id)
+    return hf_hub_download(repo_id=repo_id, filename=filename)
+
+
+def load_labels(path):
+    """Load labels from a text file (one label per line) or return empty list."""
+    if path is None:
+        return []
+    with open(path, "r", encoding="utf-8") as f:
+        return [line.strip() for line in f if line.strip()]
+
+
+def load_remedies(path):
+    """Load remedies JSON or return empty dict."""
+    if path is None:
+        return {}
+    with open(path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def build_timm_model_from_config(config, checkpoint_path, device):
+    try:
+        import timm
+    except Exception as e:
+        raise ImportError(
+            "timm is required to load timm models: pip install timm"
+        ) from e
+
+    try:
+        from safetensors.torch import load_file as load_safetensors
+    except Exception as e:
+        raise ImportError(
+            "safetensors is required: pip install safetensors"
+        ) from e
+
+    class_names = config.get("class_names") or config.get("labels")
+    if class_names is None:
+        raise ValueError("config.json must contain 'class_names' list")
+
+    model = timm.create_model(
+        config["architecture"], pretrained=False, num_classes=len(class_names)
+    )
+    state_dict = load_safetensors(checkpoint_path)
+    model.load_state_dict(state_dict)
+    model.to(device)
+    model.eval()
+    return model
+
+
+def load_model_from_hf(device):
+    """
+    Download and load the plant-disease model from Hugging Face Hub.
+
+    Loads the NFNet-F1 model (safetensors).
+
+    Returns: model, labels, remedies
+    """
+    global transform
+
+    try:
+        st_path = _download(HF_REPO_NFNET, "model.safetensors")
+        cfg_path = _download(HF_REPO_NFNET, "config.json")
+
+        with open(cfg_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+
+        labels = config.get("class_names", [])
+        
+        # Download labels.txt optionally (if available)
+        try:
+            labels_path = _download(HF_REPO_NFNET, "labels.txt")
+            if os.path.exists(labels_path):
+                file_labels = load_labels(labels_path)
+                if len(file_labels) == len(labels):
+                    labels = file_labels
+        except Exception as e:
+            logger.warning("Optional labels.txt not found or could not be loaded: %s", e)
+
+        # Download remedies.json optionally (if available)
+        remedies = {}
+        try:
+            remedies_path = _download(HF_REPO_NFNET, "remedies.json")
+            remedies = load_remedies(remedies_path)
+        except Exception as e:
+            logger.warning("Optional remedies.json not found or could not be loaded: %s", e)
+
+        img_size = config.get("input_size", INPUT_SIZE)
+        mean = config.get("normalization", {}).get("mean", IMAGENET_MEAN)
+        std = config.get("normalization", {}).get("std", IMAGENET_STD)
+        transform = transforms.Compose([
+            transforms.Resize((img_size, img_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=mean, std=std),
+        ])
+
+        model = build_timm_model_from_config(config, st_path, device)
+        logger.info("Loaded NFNet-F1 model from HF Hub (%s)", HF_REPO_NFNET)
+        return model, labels, remedies
+    except Exception as e:
+        raise RuntimeError(f"Failed to load NFNet-F1 model from HF Hub ({HF_REPO_NFNET}): {e}") from e
+
+
+def predict(model, pil_image, labels, device, topk=3, crop_filter=None):
+    """Return top-1 label, confidence, and topk list of (label, prob)."""
+    img_t = transform(pil_image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        outputs = model(img_t)
+        probs = F.softmax(outputs, dim=1)
+
+        # Apply crop filter if provided
+        if crop_filter:
+            mask = torch.zeros_like(probs)
+            for item in crop_filter:
+                if item in labels:
+                    idx = labels.index(item)
+                    mask[0, idx] = 1.0
+
+            filtered_probs = probs * mask
+            sum_probs = filtered_probs.sum(dim=1, keepdim=True)
+            if sum_probs.item() > 0:
+                probs = filtered_probs / sum_probs
+
+        actual_topk = min(topk, len(crop_filter)) if crop_filter else topk
+        top_probs, top_idxs = probs.topk(actual_topk, dim=1)
+        top_probs = top_probs.cpu().numpy()[0]
+        top_idxs = top_idxs.cpu().numpy()[0]
+        top_labels = [labels[i] for i in top_idxs]
+    return top_labels[0], float(top_probs[0]), list(zip(top_labels, top_probs.tolist()))
+

ai-backend/price-forecast/__init__.py

@@ -0,0 +1 @@
+# Price Forecast Module

ai-backend/requirements.txt

@@ -0,0 +1,34 @@
+flask==3.1.3
+pillow==12.3.0
+numpy<2,>=1.26.4
+
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch
+torchvision
+torchaudio
+
+huggingface_hub==1.27.0
+
+# optional for NFNet-F1 safetensors model
+timm==1.0.28
+safetensors==0.8.0
+
+flask-cors==6.0.5
+pandas==2.3.3
+scikit-learn==1.5.1
+joblib==1.5.3
+lightgbm==4.7.0
+gunicorn==26.0.0
+
+# Retry and testing utilities
+tenacity==9.1.4
+pytest==9.1.1
+pytest-cov==7.1.0
+pytest-mock==3.15.1
+httpx==0.28.1
+
+# YOLO harvest readiness model
+ultralytics==8.4.116
+
+# HTTP client for HF Inference API fallback
+requests==2.34.2

ai-backend/src/error_handlers.py

@@ -0,0 +1,132 @@
+"""Centralized error handlers for Flask application.
+
+Provides consistent JSON error responses and logging for all exceptions.
+"""
+import logging
+from flask import Flask, jsonify
+from werkzeug.exceptions import HTTPException
+
+from src.logging_config import log_exception
+
+logger = logging.getLogger('ai_backend.error_handlers')
+
+
+def register_error_handlers(app: Flask) -> None:
+    """Register centralized error handlers for the Flask app.
+    
+    Args:
+        app: Flask application instance
+    """
+    
+    @app.errorhandler(400)
+    def bad_request(error):
+        """Handle 400 Bad Request errors."""
+        logger.warning(f"Bad request: {error}")
+        return jsonify({
+            "error": "Bad Request",
+            "message": str(error.description) if hasattr(error, 'description') else str(error),
+            "status": 400
+        }), 400
+    
+    @app.errorhandler(404)
+    def not_found(error):
+        """Handle 404 Not Found errors."""
+        logger.warning(f"Not found: {error}")
+        return jsonify({
+            "error": "Not Found",
+            "message": "The requested resource was not found",
+            "status": 404
+        }), 404
+    
+    @app.errorhandler(500)
+    def internal_server_error(error):
+        """Handle 500 Internal Server Error."""
+        log_exception(logger, error, "Internal server error")
+        return jsonify({
+            "error": "Internal Server Error",
+            "message": "An unexpected error occurred. Please try again later.",
+            "status": 500
+        }), 500
+    
+    @app.errorhandler(HTTPException)
+    def handle_http_exception(error):
+        """Handle all HTTP exceptions."""
+        logger.warning(f"HTTP exception {error.code}: {error.description}")
+        return jsonify({
+            "error": error.name,
+            "message": error.description,
+            "status": error.code
+        }), error.code
+    
+    @app.errorhandler(Exception)
+    def handle_unexpected_error(error):
+        """Catch-all handler for unexpected exceptions.
+        
+        This prevents unhandled exceptions from returning raw 502 errors.
+        """
+        log_exception(logger, error, "Unexpected error")
+        
+        # Never expose internal error details to clients in production
+        return jsonify({
+            "error": "Internal Server Error",
+            "message": "An unexpected error occurred. Please try again later.",
+            "status": 500
+        }), 500
+
+
+def validate_content_type(request, expected='application/json'):
+    """Validate request Content-Type header.
+    
+    Args:
+        request: Flask request object
+        expected: Expected content type (default: 'application/json')
+    
+    Returns:
+        tuple: (is_valid: bool, error_response: dict or None)
+    """
+    content_type = request.content_type
+    if not content_type or expected not in content_type:
+        return False, {
+            "error": "Invalid Content-Type",
+            "message": f"Expected Content-Type: {expected}",
+            "status": 400
+        }
+    return True, None
+
+
+def validate_json_payload(request, required_fields=None):
+    """Validate JSON payload and required fields.
+    
+    Args:
+        request: Flask request object
+        required_fields: List of required field names (optional)
+    
+    Returns:
+        tuple: (is_valid: bool, data_or_error: dict)
+    """
+    try:
+        data = request.get_json(force=False)
+        if data is None:
+            return False, {
+                "error": "Invalid JSON",
+                "message": "Request body must be valid JSON",
+                "status": 400
+            }
+        
+        if required_fields:
+            missing = [f for f in required_fields if f not in data]
+            if missing:
+                return False, {
+                    "error": "Missing required fields",
+                    "message": f"Missing fields: {', '.join(missing)}",
+                    "status": 400
+                }
+        
+        return True, data
+    except Exception as e:
+        logger.warning(f"JSON parsing error: {e}")
+        return False, {
+            "error": "Invalid JSON",
+            "message": "Failed to parse JSON payload",
+            "status": 400
+        }

ai-backend/src/logging_config.py

@@ -0,0 +1,60 @@
+"""Structured logging configuration for AI Backend.
+
+Provides consistent logging format with stack traces for debugging.
+"""
+import logging
+import sys
+from typing import Optional
+
+
+def setup_logging(
+    level: int = logging.INFO,
+    format_string: Optional[str] = None
+) -> logging.Logger:
+    """Configure structured logging for the application.
+    
+    Args:
+        level: Logging level (default: INFO)
+        format_string: Custom format string (optional)
+    
+    Returns:
+        Configured logger instance
+    """
+    if format_string is None:
+        format_string = (
+            '%(asctime)s - %(name)s - %(levelname)s - '
+            '%(funcName)s:%(lineno)d - %(message)s'
+        )
+    
+    # Configure root logger
+    logging.basicConfig(
+        level=level,
+        format=format_string,
+        handlers=[
+            logging.StreamHandler(sys.stdout)
+        ],
+        force=True  # Override any existing configuration
+    )
+    
+    logger = logging.getLogger('ai_backend')
+    logger.setLevel(level)
+    
+    return logger
+
+
+def log_exception(logger: logging.Logger, exc: Exception, context: str = ""):
+    """Log an exception with full stack trace.
+    
+    Args:
+        logger: Logger instance to use
+        exc: Exception to log
+        context: Additional context about where the exception occurred
+    """
+    if context:
+        logger.error(f"{context}: {type(exc).__name__}: {str(exc)}", exc_info=True)
+    else:
+        logger.error(f"{type(exc).__name__}: {str(exc)}", exc_info=True)
+
+
+# Module-level logger is intentionally NOT created here to avoid
+# double-initializing the root logger before app.py calls setup_logging().

ai-backend/src/models/manager.py

@@ -0,0 +1,393 @@
+"""Model manager for lazy loading and caching ML models.
+
+Centralizes model loading logic and ensures models are loaded only once
+at startup with proper error handling and logging.
+"""
+import os
+import pickle
+import logging
+from typing import Dict, Any, Optional, Tuple
+import torch
+import joblib
+import numpy as np
+from huggingface_hub import hf_hub_download
+
+from src.logging_config import log_exception
+from src.utils.retry_utils import retry_with_backoff
+
+logger = logging.getLogger('ai_backend.model_manager')
+
+
+# Global model cache
+_model_cache: Dict[str, Any] = {}
+_device: Optional[torch.device] = None
+
+
+def _is_numpy_binary_compat_error(exc: Exception) -> bool:
+    """Detect common NumPy 2.x vs SciPy/sklearn binary compatibility errors."""
+    error_text = f"{type(exc).__name__}: {exc}".lower()
+    markers = (
+        "numpy.core.multiarray failed to import",
+        "_array_api not found",
+        "compiled using numpy 1",
+        "a numpy version >=",
+        "node array from the pickle has an incompatible dtype",
+    )
+    return any(marker in error_text for marker in markers)
+
+
+def get_device() -> torch.device:
+    """Get the torch device (CPU or CUDA).
+    
+    Returns:
+        torch.device instance
+    """
+    global _device
+    if _device is None:
+        _device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        logger.info(f"Using device: {_device}")
+    return _device
+
+
+@retry_with_backoff(max_attempts=3, wait_min=2.0, wait_max=10.0)
+def _download_from_hf(repo_id: str, filename: str) -> str:
+    """Download a file from Hugging Face Hub with retry.
+    
+    Args:
+        repo_id: Hugging Face repository ID
+        filename: File to download
+    
+    Returns:
+        Path to downloaded file
+    """
+    logger.info(f"Downloading {filename} from {repo_id}...")
+    return hf_hub_download(repo_id=repo_id, filename=filename)
+
+
+def load_disease_model() -> Tuple[Any, list, dict]:
+    """Load the disease detection model from HF Hub.
+    
+    Returns:
+        Tuple of (model, labels, remedies)
+    """
+    # Import model_utils which has the loading logic
+    from model_utils import load_model_from_hf
+    
+    device = get_device()
+    model, labels, remedies = load_model_from_hf(device)
+    logger.info(f"Disease model loaded — {len(labels)} labels")
+    return model, labels, remedies
+
+
+def load_crop_recommendation_models() -> Dict[str, Any]:
+    """Load crop recommendation models from HF Hub.
+    
+    Returns:
+        Dictionary containing model, StandardScaler, and MinMaxScaler
+    """
+    repo_id = os.environ.get("HF_REPO_CROP", "Arko007/agromind-crop-recommendation")
+    
+    try:
+        model = joblib.load(_download_from_hf(repo_id, "crop_predict_model.pkl"))
+        standard_scaler = joblib.load(_download_from_hf(repo_id, "crop_predict_standscaler.pkl"))
+        minmax_scaler = joblib.load(_download_from_hf(repo_id, "crop_predict_minmaxscaler.pkl"))
+        logger.info("Crop recommendation models loaded from HF Hub")
+    except Exception as exc:
+        if _is_numpy_binary_compat_error(exc):
+            raise RuntimeError(
+                "Crop recommendation models failed to load due to NumPy/SciPy binary compatibility. "
+                "Ensure scikit-learn==1.5.1 and numpy<2 are installed (matching training environment)."
+            ) from exc
+        raise
+
+    return {
+        "model": model,
+        "standard_scaler": standard_scaler,
+        "minmax_scaler": minmax_scaler
+    }
+
+
+def load_fertilizer_models() -> Dict[str, Any]:
+    """Load fertilizer prediction models from HF Hub.
+    
+    Returns:
+        Dictionary containing classifier and label_encoder
+    """
+    repo_id = os.environ.get("HF_REPO_FERTILIZER", "Arko007/agromind-fertilizer-prediction")
+    
+    try:
+        with open(_download_from_hf(repo_id, "classifier.pkl"), "rb") as f:
+            classifier = pickle.load(f)
+        with open(_download_from_hf(repo_id, "fertilizer.pkl"), "rb") as f:
+            label_encoder = pickle.load(f)
+        logger.info("Fertilizer prediction models loaded from HF Hub")
+    except Exception as exc:
+        if _is_numpy_binary_compat_error(exc):
+            raise RuntimeError(
+                "Fertilizer models failed to load due to NumPy/SciPy binary compatibility. "
+                "Ensure scikit-learn==1.5.1 and numpy<2 are installed (matching training environment)."
+            ) from exc
+        raise
+
+    return {
+        "classifier": classifier,
+        "label_encoder": label_encoder
+    }
+
+
+def load_loan_models() -> Dict[str, Any]:
+    """Load loan prediction models from HF Hub.
+    
+    Returns:
+        Dictionary containing price_model and approval_model
+    """
+    repo_id = os.environ.get("HF_REPO_LOAN", "Arko007/agromind-loan-prediction")
+    
+    try:
+        price_model = joblib.load(_download_from_hf(repo_id, "price_model.pkl"))
+        approval_model = joblib.load(_download_from_hf(repo_id, "approval_model.pkl"))
+        logger.info("Loan prediction models loaded from HF Hub")
+    except Exception as exc:
+        if _is_numpy_binary_compat_error(exc):
+            raise RuntimeError(
+                "Loan models failed to load due to NumPy/SciPy binary compatibility. "
+                "Ensure scikit-learn==1.5.1 and numpy<2 are installed (matching training environment)."
+            ) from exc
+        raise
+
+    return {
+        "price_model": price_model,
+        "approval_model": approval_model
+    }
+
+
+def initialize_models(load_all: bool = True) -> None:
+    """Initialize all models at startup.
+    
+    This function should be called during application startup to load
+    all models into the cache. Models that fail to load will be logged
+    but won't crash the application.
+    
+    Args:
+        load_all: If True, attempts to load all models. If False, only loads on-demand.
+    """
+    if not load_all:
+        logger.info("Model lazy-loading enabled. Models will load on first use.")
+        return
+    
+    logger.info("Initializing all models...")
+    
+    # Load disease model
+    try:
+        model, labels, remedies = load_disease_model()
+        _model_cache['disease_model'] = model
+        _model_cache['disease_labels'] = labels
+        _model_cache['disease_remedies'] = remedies
+    except Exception as e:
+        log_exception(logger, e, "Failed to load disease model")
+        _model_cache['disease_model'] = None
+        _model_cache['disease_labels'] = []
+        _model_cache['disease_remedies'] = {}
+    
+    # Load crop recommendation models
+    try:
+        crop_models = load_crop_recommendation_models()
+        _model_cache['crop_model'] = crop_models['model']
+        _model_cache['crop_standard_scaler'] = crop_models['standard_scaler']
+        _model_cache['crop_minmax_scaler'] = crop_models['minmax_scaler']
+    except Exception as e:
+        log_exception(logger, e, "Failed to load crop recommendation models")
+        _model_cache['crop_model'] = None
+        _model_cache['crop_standard_scaler'] = None
+        _model_cache['crop_minmax_scaler'] = None
+    
+    # Load fertilizer models
+    try:
+        fertilizer_models = load_fertilizer_models()
+        _model_cache['fertilizer_classifier'] = fertilizer_models['classifier']
+        _model_cache['fertilizer_label_encoder'] = fertilizer_models['label_encoder']
+    except Exception as e:
+        log_exception(logger, e, "Failed to load fertilizer models")
+        _model_cache['fertilizer_classifier'] = None
+        _model_cache['fertilizer_label_encoder'] = None
+    
+    # Load loan models
+    try:
+        loan_models = load_loan_models()
+        _model_cache['loan_price_model'] = loan_models['price_model']
+        _model_cache['loan_approval_model'] = loan_models['approval_model']
+    except Exception as e:
+        log_exception(logger, e, "Failed to load loan models")
+        _model_cache['loan_price_model'] = None
+        _model_cache['loan_approval_model'] = None
+    
+    logger.info("Model initialization complete")
+
+
+def get_model(model_name: str, auto_load: bool = True) -> Optional[Any]:
+    """Get a model from the cache.
+    
+    Args:
+        model_name: Name of the model to retrieve
+        auto_load: If True and model not in cache, attempt to load it
+    
+    Returns:
+        Model instance or None if not available
+    """
+    if model_name in _model_cache:
+        return _model_cache[model_name]
+    
+    if not auto_load:
+        return None
+    
+    # Attempt to load on-demand
+    logger.info(f"Model '{model_name}' not in cache, loading on-demand...")
+    
+    try:
+        if model_name == 'disease_model':
+            model, labels, remedies = load_disease_model()
+            _model_cache['disease_model'] = model
+            _model_cache['disease_labels'] = labels
+            _model_cache['disease_remedies'] = remedies
+            return model
+        elif 'crop' in model_name:
+            crop_models = load_crop_recommendation_models()
+            _model_cache['crop_model'] = crop_models['model']
+            _model_cache['crop_standard_scaler'] = crop_models['standard_scaler']
+            _model_cache['crop_minmax_scaler'] = crop_models['minmax_scaler']
+            return _model_cache.get(model_name)
+        elif 'fertilizer' in model_name:
+            fertilizer_models = load_fertilizer_models()
+            _model_cache['fertilizer_classifier'] = fertilizer_models['classifier']
+            _model_cache['fertilizer_label_encoder'] = fertilizer_models['label_encoder']
+            return _model_cache.get(model_name)
+        elif 'loan' in model_name:
+            loan_models = load_loan_models()
+            _model_cache['loan_price_model'] = loan_models['price_model']
+            _model_cache['loan_approval_model'] = loan_models['approval_model']
+            return _model_cache.get(model_name)
+    except Exception as e:
+        log_exception(logger, e, f"Failed to load model '{model_name}'")
+        return None
+    
+    return None
+
+
+def predict_crop(features: np.ndarray) -> int:
+    """Predict crop recommendation from features.
+    
+    Args:
+        features: NumPy array of shape (1, 7) with [N, P, K, temp, humidity, ph, rainfall]
+    
+    Returns:
+        Predicted crop ID (integer)
+    
+    Raises:
+        RuntimeError: If models are not loaded
+    """
+    model = get_model('crop_model')
+    minmax_scaler = get_model('crop_minmax_scaler')
+    standard_scaler = get_model('crop_standard_scaler')
+    
+    if model is None or minmax_scaler is None or standard_scaler is None:
+        raise RuntimeError("Crop recommendation models not loaded")
+    
+    # Scale features
+    scaled_features = minmax_scaler.transform(features)
+    final_features = standard_scaler.transform(scaled_features)
+    
+    # Make prediction
+    prediction = model.predict(final_features)
+    return int(prediction[0])
+
+
+def predict_fertilizer(features: np.ndarray) -> str:
+    """Predict fertilizer recommendation from features.
+    
+    Args:
+        features: NumPy array with soil and crop features
+    
+    Returns:
+        Predicted fertilizer name (string)
+    
+    Raises:
+        RuntimeError: If models are not loaded
+    """
+    classifier = get_model('fertilizer_classifier')
+    label_encoder = get_model('fertilizer_label_encoder')
+    
+    if classifier is None or label_encoder is None:
+        raise RuntimeError("Fertilizer prediction models not loaded")
+    
+    # Make prediction
+    prediction = classifier.predict(features)
+    fertilizer = label_encoder.inverse_transform(prediction)
+    return str(fertilizer[0])
+
+
+def predict_disease(pil_image, topk: int = 3) -> Tuple[str, float, list]:
+    """Predict disease from plant image.
+    
+    Args:
+        pil_image: PIL Image object
+        topk: Number of top predictions to return
+    
+    Returns:
+        Tuple of (top_label, confidence, top_k_predictions)
+    
+    Raises:
+        RuntimeError: If model is not loaded
+    """
+    from model_utils import predict
+    
+    model = get_model('disease_model')
+    labels = get_model('disease_labels')
+    
+    if model is None or not labels:
+        raise RuntimeError("Disease model not loaded")
+    
+    device = get_device()
+    return predict(model, pil_image, labels, device, topk=topk)
+
+
+def get_disease_remedy(label: str) -> Optional[str]:
+    """Get remedy for a disease label.
+    
+    Args:
+        label: Disease label
+    
+    Returns:
+        Remedy string or None if not found
+    """
+    remedies = get_model('disease_remedies')
+    if remedies is None:
+        return None
+    return remedies.get(label)
+
+
+def is_model_loaded(model_name: str) -> bool:
+    """Check if a model is loaded in the cache.
+    
+    Args:
+        model_name: Name of the model to check
+    
+    Returns:
+        True if model is loaded and not None, False otherwise
+    """
+    return model_name in _model_cache and _model_cache[model_name] is not None
+
+
+def get_model_status() -> Dict[str, bool]:
+    """Get the status of all models.
+    
+    Returns:
+        Dictionary mapping model names to their loaded status
+    """
+    return {
+        'disease_model': is_model_loaded('disease_model'),
+        'crop_model': is_model_loaded('crop_model'),
+        'fertilizer_classifier': is_model_loaded('fertilizer_classifier'),
+        'loan_price_model': is_model_loaded('loan_price_model'),
+        'loan_approval_model': is_model_loaded('loan_approval_model'),
+        'harvest_readiness_model': is_model_loaded('harvest_readiness_model'),
+    }

ai-backend/src/utils/retry_utils.py

@@ -0,0 +1,165 @@
+"""Retry utilities with exponential backoff.
+
+Provides decorators for retrying operations with configurable backoff.
+Uses tenacity library for robust retry logic.
+"""
+import logging
+from functools import wraps
+from typing import Callable, Optional, Type, Tuple
+import time
+
+try:
+    from tenacity import (
+        retry,
+        stop_after_attempt,
+        wait_exponential,
+        retry_if_exception_type,
+        before_sleep_log,
+        RetryError
+    )
+    HAS_TENACITY = True
+except ImportError:
+    HAS_TENACITY = False
+
+logger = logging.getLogger('ai_backend.retry_utils')
+
+
+def retry_with_backoff(
+    max_attempts: int = 3,
+    wait_min: float = 1.0,
+    wait_max: float = 10.0,
+    retry_on_exceptions: Optional[Tuple[Type[Exception], ...]] = None
+) -> Callable:
+    """Decorator to retry a function with exponential backoff.
+    
+    Args:
+        max_attempts: Maximum number of retry attempts (default: 3)
+        wait_min: Minimum wait time in seconds (default: 1.0)
+        wait_max: Maximum wait time in seconds (default: 10.0)
+        retry_on_exceptions: Tuple of exception types to retry on (default: all exceptions)
+    
+    Returns:
+        Decorated function with retry logic
+    
+    Example:
+        @retry_with_backoff(max_attempts=3, wait_min=1.0, wait_max=10.0)
+        def call_external_api():
+            response = requests.get("https://api.example.com/data")
+            response.raise_for_status()
+            return response.json()
+    """
+    if HAS_TENACITY:
+        # Use tenacity for robust retry logic
+        if retry_on_exceptions:
+            retry_condition = retry_if_exception_type(retry_on_exceptions)
+        else:
+            retry_condition = retry_if_exception_type(Exception)
+        
+        return retry(
+            stop=stop_after_attempt(max_attempts),
+            wait=wait_exponential(multiplier=wait_min, max=wait_max),
+            retry=retry_condition,
+            before_sleep=before_sleep_log(logger, logging.WARNING),
+            reraise=True
+        )
+    else:
+        # Fallback to simple retry logic if tenacity is not available
+        def decorator(func: Callable) -> Callable:
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                last_exception = None
+                for attempt in range(max_attempts):
+                    try:
+                        return func(*args, **kwargs)
+                    except Exception as e:
+                        last_exception = e
+                        if retry_on_exceptions and not isinstance(e, retry_on_exceptions):
+                            # Don't retry if it's not a retryable exception
+                            raise
+                        
+                        if attempt < max_attempts - 1:
+                            # Calculate wait time with exponential backoff
+                            wait_time = min(wait_min * (2 ** attempt), wait_max)
+                            logger.warning(
+                                f"Attempt {attempt + 1}/{max_attempts} failed: {e}. "
+                                f"Retrying in {wait_time:.1f}s..."
+                            )
+                            time.sleep(wait_time)
+                        else:
+                            logger.error(
+                                f"All {max_attempts} attempts failed. Last error: {e}"
+                            )
+                
+                # Raise the last exception if all attempts failed
+                if last_exception:
+                    raise last_exception
+            
+            return wrapper
+        return decorator
+
+
+def retry_model_inference(
+    max_attempts: int = 2,
+    wait_min: float = 0.5,
+    wait_max: float = 2.0
+) -> Callable:
+    """Specialized retry decorator for model inference operations.
+    
+    Uses shorter wait times and fewer attempts since model inference
+    failures are typically not transient.
+    
+    Args:
+        max_attempts: Maximum number of retry attempts (default: 2)
+        wait_min: Minimum wait time in seconds (default: 0.5)
+        wait_max: Maximum wait time in seconds (default: 2.0)
+    
+    Returns:
+        Decorated function with retry logic
+    """
+    return retry_with_backoff(
+        max_attempts=max_attempts,
+        wait_min=wait_min,
+        wait_max=wait_max,
+        retry_on_exceptions=(RuntimeError, OSError, IOError)
+    )
+
+
+def with_timeout(timeout_seconds: float) -> Callable:
+    """Decorator to add timeout to a function.
+    
+    Note: This is a simple implementation. For production use with true
+    timeouts on blocking operations, consider using concurrent.futures
+    or signal-based timeouts.
+    
+    Args:
+        timeout_seconds: Maximum execution time in seconds
+    
+    Returns:
+        Decorated function with timeout
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            import signal
+            
+            def timeout_handler(signum, frame):
+                raise TimeoutError(f"Function {func.__name__} timed out after {timeout_seconds}s")
+            
+            # Set up signal handler (Unix-like systems only)
+            try:
+                signal.signal(signal.SIGALRM, timeout_handler)
+                signal.alarm(int(timeout_seconds))
+                try:
+                    result = func(*args, **kwargs)
+                finally:
+                    signal.alarm(0)  # Cancel the alarm
+                return result
+            except AttributeError:
+                # SIGALRM not available (e.g., on Windows)
+                logger.warning(
+                    f"Timeout decorator not supported on this platform for {func.__name__}"
+                )
+                return func(*args, **kwargs)
+        
+        return wrapper
+    return decorator

ai-backend/tests/conftest.py

@@ -0,0 +1,187 @@
+"""Pytest configuration and shared fixtures for AI Backend tests."""
+import pytest
+import sys
+import os
+from unittest.mock import MagicMock, Mock
+import numpy as np
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+
+@pytest.fixture
+def app():
+    """Create Flask app for testing."""
+    # Import app here to avoid loading models during test collection
+    from app import app as flask_app
+    flask_app.config['TESTING'] = True
+    return flask_app
+
+
+@pytest.fixture
+def client(app):
+    """Create test client for Flask app."""
+    return app.test_client()
+
+
+@pytest.fixture
+def mock_disease_model():
+    """Mock disease detection model."""
+    model = MagicMock()
+    labels = ["healthy", "bacterial_blight", "leaf_spot", "rust"]
+    remedies = {
+        "bacterial_blight": "Apply copper-based fungicide",
+        "leaf_spot": "Remove infected leaves, apply fungicide",
+        "rust": "Apply sulfur-based fungicide"
+    }
+    return model, labels, remedies
+
+
+@pytest.fixture
+def mock_crop_model():
+    """Mock crop recommendation model and scalers."""
+    model = MagicMock()
+    model.predict = MagicMock(return_value=np.array([1]))  # Returns "Rice"
+    
+    standard_scaler = MagicMock()
+    standard_scaler.transform = MagicMock(side_effect=lambda x: x)
+    
+    minmax_scaler = MagicMock()
+    minmax_scaler.transform = MagicMock(side_effect=lambda x: x)
+    
+    return {
+        'model': model,
+        'standard_scaler': standard_scaler,
+        'minmax_scaler': minmax_scaler
+    }
+
+
+@pytest.fixture
+def mock_fertilizer_model():
+    """Mock fertilizer prediction model."""
+    classifier = MagicMock()
+    classifier.predict = MagicMock(return_value=np.array([0]))
+    
+    label_encoder = MagicMock()
+    label_encoder.inverse_transform = MagicMock(return_value=np.array(["Urea"]))
+    
+    return {
+        'classifier': classifier,
+        'label_encoder': label_encoder
+    }
+
+
+@pytest.fixture
+def mock_loan_models():
+    """Mock loan prediction models."""
+    price_model = MagicMock()
+    price_model.predict = MagicMock(return_value=np.array([50000]))
+    
+    approval_model = MagicMock()
+    approval_model.predict = MagicMock(return_value=np.array([1]))
+    
+    return {
+        'price_model': price_model,
+        'approval_model': approval_model
+    }
+
+
+@pytest.fixture
+def sample_crop_input():
+    """Sample input for crop recommendation."""
+    return {
+        "N": 50,
+        "P": 30,
+        "K": 40,
+        "temperature": 28,
+        "humidity": 65,
+        "ph": 6.5,
+        "rainfall": 200
+    }
+
+
+@pytest.fixture
+def sample_fertilizer_input():
+    """Sample input for fertilizer prediction."""
+    return {
+        "temperature": 28,
+        "humidity": 65,
+        "moisture": 45,
+        "soil_type": "Loamy",
+        "crop_type": "Wheat",
+        "nitrogen": 50,
+        "potassium": 40,
+        "phosphorus": 30
+    }
+
+
+@pytest.fixture
+def sample_loan_input():
+    """Sample input for loan prediction."""
+    return {
+        "area": 5.5,
+        "land_contour": "flat",
+        "distance_from_road": 2.0,
+        "soil_type": "loam",
+        "income": 150000,
+        "loan_request": 50000
+    }
+
+
+@pytest.fixture
+def mock_pil_image():
+    """Mock PIL Image for disease detection."""
+    try:
+        from PIL import Image
+        import io
+        # Create a simple 224x224 RGB image
+        img = Image.new('RGB', (224, 224), color='green')
+        return img
+    except ImportError:
+        return None
+
+
+@pytest.fixture
+def sample_price_forecast_input():
+    """Sample input for price forecasting."""
+    return {
+        "commodity_type": "wheat",
+        "historical_prices": [
+            {"date": "2026-01-01", "price": 55, "volume": 1000},
+            {"date": "2026-01-02", "price": 56, "volume": 1000},
+            {"date": "2026-01-03", "price": 54, "volume": 1000},
+            {"date": "2026-01-04", "price": 57, "volume": 1000},
+            {"date": "2026-01-05", "price": 55, "volume": 1000}
+        ],
+        "forecast_days": 7
+    }
+
+
+@pytest.fixture
+def sample_yield_input():
+    """Sample input for yield prediction."""
+    return {
+        "crop_type": "groundnut",
+        "area_hectares": 5,
+        "soil_data": {"nitrogen": 50, "phosphorus": 30, "potassium": 40, "ph": 6.5},
+        "weather_data": {"rainfall": 800, "temperature": 28, "humidity": 65}
+    }
+
+
+@pytest.fixture
+def sample_tariff_input():
+    """Sample input for tariff simulation."""
+    return {
+        "tariff_pct": 45,
+        "period": "6_months",
+        "global_price_shock": 0
+    }
+
+
+@pytest.fixture(autouse=True)
+def reset_model_cache():
+    """Reset model cache before each test."""
+    from src.models import manager
+    manager._model_cache.clear()
+    yield
+    manager._model_cache.clear()

ai-backend/tests/test_api_integration.py

@@ -0,0 +1,552 @@
+"""Integration tests for API endpoints.
+
+Tests all endpoints with various scenarios including:
+- Happy path with valid inputs
+- Invalid inputs and validation
+- Error handling and retry logic
+- Malformed JSON payloads
+"""
+import pytest
+import json
+import io
+from unittest.mock import patch, MagicMock
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+
+class TestHealthEndpoint:
+    """Test health check endpoint."""
+    
+    def test_health_endpoint_returns_200(self, client):
+        """Health endpoint should return 200 OK."""
+        response = client.get('/health')
+        assert response.status_code == 200
+        data = response.get_json()
+        assert data['status'] == 'ok'
+    
+    def test_root_endpoint_returns_200(self, client):
+        """Root endpoint should return welcome message."""
+        response = client.get('/')
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'message' in data
+
+
+class TestCropRecommendationEndpoint:
+    """Test crop recommendation endpoint."""
+    
+    def test_crop_recommendation_happy_path(
+        self, client, sample_crop_input
+    ):
+        """Test successful crop recommendation."""
+        from src.models import manager
+        # Inject mocks into model cache
+        mock_model = MagicMock()
+        mock_model.predict = MagicMock(return_value=[1])  # Rice
+        mock_ms = MagicMock()
+        mock_ms.transform = MagicMock(side_effect=lambda x: x)
+        mock_sc = MagicMock()
+        mock_sc.transform = MagicMock(side_effect=lambda x: x)
+        manager._model_cache['crop_model'] = mock_model
+        manager._model_cache['crop_minmax_scaler'] = mock_ms
+        manager._model_cache['crop_standard_scaler'] = mock_sc
+        
+        response = client.post(
+            '/crop_recommendation',
+            data=json.dumps(sample_crop_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert data['success'] is True
+        assert 'crop' in data
+        assert 'message' in data
+        assert 'prediction_id' in data
+    
+    def test_crop_recommendation_missing_field(self, client):
+        """Test crop recommendation with missing required field."""
+        incomplete_data = {
+            "N": 50,
+            "P": 30,
+            # Missing K and other fields
+        }
+        
+        response = client.post(
+            '/crop_recommendation',
+            data=json.dumps(incomplete_data),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+    
+    def test_crop_recommendation_invalid_range(self, client, sample_crop_input):
+        """Test crop recommendation with out-of-range values."""
+        sample_crop_input['N'] = 150  # Out of valid range (0-100)
+        
+        response = client.post(
+            '/crop_recommendation',
+            data=json.dumps(sample_crop_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+    
+    def test_crop_recommendation_invalid_json(self, client):
+        """Test crop recommendation with malformed JSON."""
+        response = client.post(
+            '/crop_recommendation',
+            data='invalid json{',
+            content_type='application/json'
+        )
+        
+        assert response.status_code in [400, 500]
+    
+    def test_crop_recommendation_invalid_data_type(self, client):
+        """Test crop recommendation with invalid data types."""
+        invalid_data = {
+            "N": "not_a_number",
+            "P": 30,
+            "K": 40,
+            "temperature": 28,
+            "humidity": 65,
+            "ph": 6.5,
+            "rainfall": 200
+        }
+        
+        response = client.post(
+            '/crop_recommendation',
+            data=json.dumps(invalid_data),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+    
+    def test_crop_recommendation_model_not_loaded(self, client, sample_crop_input):
+        """Test crop recommendation when model is not loaded."""
+        from src.models import manager
+        manager._model_cache['crop_model'] = None
+        manager._model_cache['crop_minmax_scaler'] = None
+        manager._model_cache['crop_standard_scaler'] = None
+        response = client.post(
+            '/crop_recommendation',
+            data=json.dumps(sample_crop_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 500
+        data = response.get_json()
+        assert 'error' in data
+
+
+class TestFertilizerPredictionEndpoint:
+    """Test fertilizer prediction endpoint."""
+    
+    def test_fertilizer_prediction_happy_path(
+        self, client, sample_fertilizer_input
+    ):
+        """Test successful fertilizer prediction."""
+        import numpy as np
+        from src.models import manager
+        # Inject mocks into model cache
+        mock_classifier = MagicMock()
+        mock_classifier.predict = MagicMock(return_value=np.array([0]))
+        mock_encoder = MagicMock()
+        mock_encoder.inverse_transform = MagicMock(return_value=np.array(["Urea"]))
+        manager._model_cache['fertilizer_classifier'] = mock_classifier
+        manager._model_cache['fertilizer_label_encoder'] = mock_encoder
+        
+        response = client.post(
+            '/fertilizer_prediction',
+            data=json.dumps(sample_fertilizer_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'fertilizer' in data
+    
+    def test_fertilizer_prediction_missing_field(self, client):
+        """Test fertilizer prediction with missing fields."""
+        incomplete_data = {
+            "temperature": 28,
+            "humidity": 65,
+            # Missing other required fields
+        }
+        
+        response = client.post(
+            '/fertilizer_prediction',
+            data=json.dumps(incomplete_data),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+    
+    def test_fertilizer_prediction_invalid_soil_type(self, client, sample_fertilizer_input):
+        """Test fertilizer prediction with invalid soil type."""
+        sample_fertilizer_input['soil_type'] = "InvalidSoil"
+        
+        response = client.post(
+            '/fertilizer_prediction',
+            data=json.dumps(sample_fertilizer_input),
+            content_type='application/json'
+        )
+        
+        # Should return 400 for invalid soil type
+        assert response.status_code in [400, 500]
+
+
+class TestDiseasePredictionEndpoint:
+    """Test disease prediction endpoint."""
+    
+    @patch('app.predict')
+    def test_disease_prediction_happy_path(
+        self, mock_predict, client, mock_pil_image
+    ):
+        """Test successful disease prediction."""
+        if mock_pil_image is None:
+            pytest.skip("PIL not available")
+        
+        from src.models import manager
+        mock_model = MagicMock()
+        manager._model_cache['disease_model'] = mock_model
+        manager._model_cache['disease_labels'] = ["healthy", "bacterial_blight", "leaf_spot"]
+        manager._model_cache['disease_remedies'] = {"bacterial_blight": "Apply copper-based fungicide"}
+        
+        mock_predict.return_value = ("bacterial_blight", 0.95, [
+            ("bacterial_blight", 0.95),
+            ("leaf_spot", 0.03),
+            ("healthy", 0.02)
+        ])
+        
+        # Create image bytes
+        img_byte_arr = io.BytesIO()
+        mock_pil_image.save(img_byte_arr, format='PNG')
+        img_byte_arr.seek(0)
+        
+        response = client.post(
+            '/predict_disease',
+            data={'file': (img_byte_arr, 'test.png')},
+            content_type='multipart/form-data'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'label' in data
+        assert 'confidence' in data
+    
+    def test_disease_prediction_no_file(self, client):
+        """Test disease prediction without file."""
+        response = client.post(
+            '/predict_disease',
+            data={},
+            content_type='multipart/form-data'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+    
+    def test_disease_prediction_model_not_loaded(self, client, mock_pil_image):
+        """Test disease prediction when model not loaded."""
+        if mock_pil_image is None:
+            pytest.skip("PIL not available")
+        
+        from src.models import manager
+        manager._model_cache['disease_model'] = None
+        
+        img_byte_arr = io.BytesIO()
+        mock_pil_image.save(img_byte_arr, format='PNG')
+        img_byte_arr.seek(0)
+        
+        response = client.post(
+            '/predict_disease',
+            data={'file': (img_byte_arr, 'test.png')},
+            content_type='multipart/form-data'
+        )
+        
+        assert response.status_code == 503
+        data = response.get_json()
+        assert 'error' in data
+
+
+class TestLoanPredictionEndpoint:
+    """Test loan prediction endpoint."""
+    
+    def test_loan_prediction_happy_path(
+        self, client, sample_loan_input
+    ):
+        """Test successful loan prediction."""
+        import numpy as np
+        from src.models import manager
+        # Inject mocks with feature_names_in_ for column ordering
+        mock_price = MagicMock()
+        mock_price.predict = MagicMock(return_value=np.array([50000]))
+        mock_price.feature_names_in_ = [
+            'area', 'distance_from_road', 'income',
+            'land_contour_hilly', 'land_contour_sloping',
+            'soil_type_clay', 'soil_type_sandy', 'soil_type_silty'
+        ]
+        mock_approval = MagicMock()
+        mock_approval.predict = MagicMock(return_value=np.array([1]))
+        manager._model_cache['loan_price_model'] = mock_price
+        manager._model_cache['loan_approval_model'] = mock_approval
+        
+        response = client.post(
+            '/loan_prediction',
+            data=json.dumps(sample_loan_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert 'predicted_price' in data or 'approval_status' in data
+    
+    def test_loan_prediction_missing_fields(self, client):
+        """Test loan prediction with missing fields."""
+        incomplete_data = {
+            "farmer_age": 35,
+            # Missing other fields
+        }
+        
+        response = client.post(
+            '/loan_prediction',
+            data=json.dumps(incomplete_data),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+
+
+class TestPriceForecastEndpoint:
+    """Test price forecast endpoint."""
+    
+    def test_price_forecast_happy_path(self, client, sample_price_forecast_input):
+        """Test successful price forecast."""
+        response = client.post(
+            '/ai/price-forecast',
+            data=json.dumps(sample_price_forecast_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert data.get('success') is True
+        assert 'data' in data
+    
+    def test_price_forecast_insufficient_data(self, client):
+        """Test price forecast with insufficient historical data."""
+        insufficient_data = {
+            "commodity": "wheat",
+            "historical_data": [
+                {"date": "2026-01-01", "price": 55},
+                {"date": "2026-01-02", "price": 56}
+            ],
+            "forecast_days": 7
+        }
+        
+        response = client.post(
+            '/ai/price-forecast',
+            data=json.dumps(insufficient_data),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+    
+    def test_price_forecast_invalid_days(self, client, sample_price_forecast_input):
+        """Test price forecast with invalid forecast days."""
+        sample_price_forecast_input['forecast_days'] = 365  # Invalid
+        
+        response = client.post(
+            '/ai/price-forecast',
+            data=json.dumps(sample_price_forecast_input),
+            content_type='application/json'
+        )
+        
+        # Should either reject or default to valid value
+        assert response.status_code in [200, 400]
+
+
+class TestYieldPredictionEndpoint:
+    """Test yield prediction endpoint."""
+    
+    def test_yield_prediction_happy_path(self, client, sample_yield_input):
+        """Test successful yield prediction."""
+        response = client.post(
+            '/ai/yield-predict',
+            data=json.dumps(sample_yield_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert data.get('success') is True
+        assert data['data']['predicted_yield_kg_per_ha'] > 0
+    
+    def test_yield_prediction_unknown_crop(self, client, sample_yield_input):
+        """Test yield prediction with unknown crop."""
+        sample_yield_input['crop'] = "unknown_crop_xyz"
+        
+        response = client.post(
+            '/ai/yield-predict',
+            data=json.dumps(sample_yield_input),
+            content_type='application/json'
+        )
+        
+        # Unknown crops get a default yield, endpoint returns 200 with default
+        assert response.status_code == 200
+
+
+class TestTariffSimulationEndpoint:
+    """Test tariff simulation endpoint."""
+    
+    def test_tariff_simulation_happy_path(self, client, sample_tariff_input):
+        """Test successful tariff simulation."""
+        response = client.post(
+            '/ai/tariff-simulate',
+            data=json.dumps(sample_tariff_input),
+            content_type='application/json'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert data.get('success') is True
+        assert 'data' in data
+        assert 'sensitivity_analysis' in data['data']
+    
+    def test_tariff_simulation_missing_fields(self, client):
+        """Test tariff simulation with missing fields."""
+        incomplete_data = {
+            "commodity": "wheat",
+            "current_tariff_pct": 35
+            # Missing other fields
+        }
+        
+        response = client.post(
+            '/ai/tariff-simulate',
+            data=json.dumps(incomplete_data),
+            content_type='application/json'
+        )
+        
+        # Endpoint uses defaults for all fields - returns 200 always
+        assert response.status_code == 200
+
+
+class TestCROPICEndpoint:
+    """Test CROPIC crop damage analysis endpoint."""
+    
+    def test_cropic_analyze_happy_path(self, client, mock_pil_image):
+        """Test successful CROPIC analysis."""
+        if mock_pil_image is None:
+            pytest.skip("PIL not available")
+        
+        img_byte_arr = io.BytesIO()
+        mock_pil_image.save(img_byte_arr, format='PNG')
+        img_byte_arr.seek(0)
+        
+        response = client.post(
+            '/ai/cropic/analyze',
+            data={'file': (img_byte_arr, 'crop.png')},
+            content_type='multipart/form-data'
+        )
+        
+        assert response.status_code == 200
+        data = response.get_json()
+        assert data.get('success') is True
+        assert 'damage_type' in data['data']
+        assert 'damage_percentage' in data['data']
+        assert 'recommendations' in data['data']
+    
+    def test_cropic_analyze_no_image(self, client):
+        """Test CROPIC analysis without image."""
+        response = client.post(
+            '/ai/cropic/analyze',
+            data={},
+            content_type='multipart/form-data'
+        )
+        
+        assert response.status_code == 400
+        data = response.get_json()
+        assert 'error' in data
+
+
+class TestErrorHandling:
+    """Test error handling across endpoints."""
+    
+    def test_404_not_found(self, client):
+        """Test 404 error for non-existent endpoint."""
+        response = client.get('/nonexistent')
+        assert response.status_code == 404
+    
+    def test_405_method_not_allowed(self, client):
+        """Test 405 error for wrong HTTP method."""
+        response = client.get('/crop_recommendation')  # Should be POST
+        assert response.status_code == 405
+    
+    @pytest.mark.parametrize("endpoint", [
+        "/crop_recommendation",
+        "/fertilizer_prediction",
+        "/loan_prediction",
+        "/ai/price-forecast",
+        "/ai/yield-predict",
+        "/ai/tariff-simulate"
+    ])
+    def test_missing_content_type(self, client, endpoint):
+        """Test endpoints with missing Content-Type header."""
+        response = client.post(
+            endpoint,
+            data='{"test": "data"}'
+            # No content_type specified
+        )
+        
+        # Should handle gracefully, either 400 or attempt to parse
+        assert response.status_code in [200, 400, 415, 500]
+
+
+class TestRetryBehavior:
+    """Test retry behavior with transient failures."""
+    
+    def test_transient_failure_then_success(
+        self, client, sample_crop_input
+    ):
+        """Test that transient failures are retried successfully."""
+        from src.models import manager
+        # Inject mocks into model cache
+        mock_model = MagicMock()
+        mock_model.predict = MagicMock(side_effect=[
+            Exception("Transient error"),
+            [1]  # Success on retry
+        ])
+        mock_ms = MagicMock()
+        mock_ms.transform = MagicMock(side_effect=lambda x: x)
+        mock_sc = MagicMock()
+        mock_sc.transform = MagicMock(side_effect=lambda x: x)
+        manager._model_cache['crop_model'] = mock_model
+        manager._model_cache['crop_minmax_scaler'] = mock_ms
+        manager._model_cache['crop_standard_scaler'] = mock_sc
+        
+        # Note: This test will only work if retry logic is implemented
+        # For now, it will fail on first exception
+        response = client.post(
+            '/crop_recommendation',
+            data=json.dumps(sample_crop_input),
+            content_type='application/json'
+        )
+        
+        # Without retry wrapper, this will return 500
+        # With retry wrapper, should succeed
+        assert response.status_code in [200, 500]

ai-backend/tests/test_endpoints.py

@@ -0,0 +1,464 @@
+"""
+AI Backend Tests
+"""
+import pytest
+import json
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+
+class TestHealthEndpoint:
+    """Test health check endpoint"""
+
+    def test_health_response_format(self):
+        """Health endpoint should return correct format"""
+        expected_keys = {"status", "message"}
+        # Simulating expected response structure
+        response = {"status": "healthy", "message": "API is running"}
+        assert set(response.keys()) == expected_keys
+        assert response["status"] == "healthy"
+
+
+class TestPriceForecast:
+    """Test price forecasting functionality"""
+
+    def test_minimum_data_points_required(self):
+        """Should require at least 5 historical data points"""
+        min_required = 5
+        short_data = [{"date": "2026-01-01", "price": 55}] * 4
+        long_data = [{"date": "2026-01-01", "price": 55}] * 5
+
+        assert len(short_data) < min_required
+        assert len(long_data) >= min_required
+
+    def test_forecast_days_validation(self):
+        """Forecast days should be 7, 30, or 90"""
+        valid_days = [7, 30, 90]
+        
+        for days in valid_days:
+            assert days in [7, 30, 90]
+        
+        # Invalid should default to 30
+        invalid_days = 45
+        default_days = 30 if invalid_days not in valid_days else invalid_days
+        assert default_days == 30
+
+    def test_confidence_interval_calculation(self):
+        """Confidence intervals should widen with forecast horizon"""
+        import math
+        
+        daily_volatility = 0.02
+        last_price = 55
+        
+        ci_day_1 = daily_volatility * last_price * math.sqrt(1) * 1.96
+        ci_day_30 = daily_volatility * last_price * math.sqrt(30) * 1.96
+        
+        assert ci_day_30 > ci_day_1
+        assert ci_day_30 == pytest.approx(ci_day_1 * math.sqrt(30), rel=0.01)
+
+    def test_feature_preparation(self):
+        """Feature preparation should produce valid arrays"""
+        # Sample historical data
+        historical_prices = [
+            {"date": "2026-01-01", "price": 55, "volume": 1000},
+            {"date": "2026-01-02", "price": 56, "volume": 1200},
+            {"date": "2026-01-03", "price": 54, "volume": 900},
+            {"date": "2026-01-04", "price": 57, "volume": 1100},
+            {"date": "2026-01-05", "price": 55, "volume": 1050},
+        ]
+        
+        prices = [p["price"] for p in historical_prices]
+        
+        # Basic statistics using standard library
+        price_mean = sum(prices) / len(prices)
+        price_min = min(prices)
+        price_max = max(prices)
+        
+        assert price_mean == pytest.approx(55.4, rel=0.01)
+        assert price_min == 54
+        assert price_max == 57
+
+
+class TestYieldPrediction:
+    """Test yield prediction functionality"""
+
+    def test_base_yield_lookup(self):
+        """Should return base yield for known crops"""
+        base_yields = {
+            "groundnut": 1800,
+            "sunflower": 1200,
+            "soybean": 2000,
+            "mustard": 1100,
+        }
+        
+        for crop, yield_value in base_yields.items():
+            assert yield_value > 0
+            assert crop in base_yields
+
+    def test_soil_factor_calculation(self):
+        """Soil factor should be between 0.5 and 1.5"""
+        # Test optimal conditions
+        n, p, k = 50, 30, 40
+        soil_factor = 1.0
+        
+        if 40 <= n <= 60 and 25 <= p <= 40 and 30 <= k <= 50:
+            soil_factor = 1.1
+        
+        assert 0.5 <= soil_factor <= 1.5
+
+    def test_weather_factor_calculation(self):
+        """Weather factor should adjust based on rainfall and temperature"""
+        rainfall = 800
+        temp = 28
+        weather_factor = 1.0
+        
+        if 600 <= rainfall <= 1000:
+            weather_factor = 1.1
+        
+        if 25 <= temp <= 32:
+            weather_factor *= 1.05
+        
+        assert weather_factor == pytest.approx(1.155, rel=0.01)
+
+
+class TestTariffSimulation:
+    """Test tariff impact simulation"""
+
+    def test_import_elasticity_effect(self):
+        """Higher tariffs should reduce imports"""
+        base_import = 15000000
+        import_elasticity = -0.8
+        tariff_change = 0.05  # 5% increase
+        
+        import_change = tariff_change * import_elasticity
+        new_import = base_import * (1 + import_change)
+        
+        assert new_import < base_import
+
+    def test_price_pass_through(self):
+        """Price changes should pass through to farmers and consumers"""
+        price_change = 10  # 10% change
+        farmer_pass_through = 0.6
+        consumer_pass_through = 0.8
+        
+        farmer_impact = price_change * farmer_pass_through
+        consumer_impact = price_change * consumer_pass_through
+        
+        assert farmer_impact == 6
+        assert consumer_impact == 8
+        assert farmer_impact <= consumer_impact
+
+    def test_sensitivity_analysis(self):
+        """Should generate sensitivity table for different tariff levels"""
+        tariff_levels = [25, 30, 35, 40, 45, 50]
+        sensitivity_results = []
+        
+        for tariff in tariff_levels:
+            result = {
+                "tariff_pct": tariff,
+                "import_volume": 15 - (tariff - 35) * 0.1,
+            }
+            sensitivity_results.append(result)
+        
+        assert len(sensitivity_results) == 6
+        # Higher tariffs should result in lower imports
+        imports = [r["import_volume"] for r in sensitivity_results]
+        assert imports == sorted(imports, reverse=True)
+
+
+class TestCROPIC:
+    """Test crop damage analysis"""
+
+    def test_image_size_validation(self):
+        """Should validate image dimensions"""
+        min_dimension = 100
+        max_size_bytes = 10 * 1024 * 1024  # 10MB
+        
+        valid_image = {"width": 640, "height": 480, "size": 500000}
+        invalid_image = {"width": 50, "height": 50, "size": 5000}
+        
+        assert valid_image["width"] >= min_dimension
+        assert valid_image["height"] >= min_dimension
+        assert valid_image["size"] <= max_size_bytes
+        
+        assert invalid_image["width"] < min_dimension
+
+    def test_damage_classification(self):
+        """Should classify damage types correctly"""
+        damage_types = [
+            "none",
+            "pest_damage",
+            "disease",
+            "drought_stress",
+            "flood_damage",
+            "bacterial_infection",
+            "fungal_disease",
+        ]
+        
+        for dtype in damage_types:
+            assert isinstance(dtype, str)
+            assert len(dtype) > 0
+
+    def test_damage_percentage_range(self):
+        """Damage percentage should be between 0 and 100"""
+        import random
+        
+        for _ in range(10):
+            damage_pct = random.randint(0, 100)
+            assert 0 <= damage_pct <= 100
+
+    def test_recommendation_generation(self):
+        """Should generate recommendations based on damage"""
+        def get_recommendations(damage_type, damage_pct):
+            recs = []
+            if damage_type == "none":
+                recs.append("monitoring")
+            elif damage_type == "pest_damage":
+                recs.append("pesticide_application")
+            elif damage_pct >= 50:
+                recs.append("insurance_claim")
+            return recs
+        
+        assert "monitoring" in get_recommendations("none", 0)
+        assert "pesticide_application" in get_recommendations("pest_damage", 30)
+        assert "insurance_claim" in get_recommendations("disease", 60)
+
+
+class TestCropRecommendation:
+    """Test crop recommendation functionality"""
+
+    def test_input_validation_ranges(self):
+        """Should validate input ranges"""
+        valid_inputs = {
+            "N": 50,  # 0-100
+            "P": 30,  # 0-100
+            "K": 40,  # 0-100
+            "temperature": 28,  # -10 to 50
+            "humidity": 65,  # 0-100
+            "ph": 6.5,  # 0-14
+            "rainfall": 200,  # 0-500
+        }
+        
+        assert 0 <= valid_inputs["N"] <= 100
+        assert 0 <= valid_inputs["P"] <= 100
+        assert 0 <= valid_inputs["K"] <= 100
+        assert -10 <= valid_inputs["temperature"] <= 50
+        assert 0 <= valid_inputs["humidity"] <= 100
+        assert 0 <= valid_inputs["ph"] <= 14
+        assert 0 <= valid_inputs["rainfall"] <= 500
+
+    def test_crop_dictionary(self):
+        """Should have valid crop mappings"""
+        crop_dict = {
+            1: "Rice", 2: "Maize", 3: "Jute", 4: "Cotton",
+            5: "Coconut", 6: "Papaya", 7: "Orange",
+        }
+        
+        assert len(crop_dict) > 0
+        for key, value in crop_dict.items():
+            assert isinstance(key, int)
+            assert isinstance(value, str)
+
+
+class TestSaffronClassifier:
+    """Test saffron authenticity classification"""
+
+    def test_saffron_classes(self):
+        """Should have exactly 3 saffron classes"""
+        classes = ["mogra", "lacha", "adulterated"]
+        assert len(classes) == 3
+        assert "mogra" in classes
+        assert "lacha" in classes
+        assert "adulterated" in classes
+
+    def test_saffron_response_format(self):
+        """Saffron response should have correct fields"""
+        expected_keys = {"model", "prediction", "confidence", "all_predictions", "timestamp"}
+        response = {
+            "model": "saffron-verify-pretrained",
+            "prediction": "mogra",
+            "confidence": 0.95,
+            "all_predictions": [
+                {"label": "mogra", "confidence": 0.95},
+                {"label": "lacha", "confidence": 0.04},
+                {"label": "adulterated", "confidence": 0.01},
+            ],
+            "timestamp": "2026-03-07T08:00:00Z",
+        }
+        assert set(response.keys()) == expected_keys
+        assert response["model"] == "saffron-verify-pretrained"
+        assert 0 <= response["confidence"] <= 1
+        assert response["prediction"] in ["mogra", "lacha", "adulterated"]
+
+    def test_saffron_grade_mapping(self):
+        """Saffron grades should map correctly"""
+        grade_map = {
+            "mogra": "Grade A",
+            "lacha": "Grade B",
+            "adulterated": "Adulterated",
+        }
+        assert grade_map["mogra"] == "Grade A"
+        assert grade_map["lacha"] == "Grade B"
+        assert grade_map["adulterated"] == "Adulterated"
+
+
+class TestWalnutDefectClassifier:
+    """Test walnut defect classification"""
+
+    def test_walnut_defect_classes(self):
+        """Should have 4 defect classes"""
+        classes = ["Healthy", "Black Spot", "Shriveled", "Damaged"]
+        assert len(classes) == 4
+        assert "Healthy" in classes
+
+    def test_walnut_defect_response_format(self):
+        """Walnut defect response should have correct fields"""
+        response = {
+            "model": "walnut-defect-classifier",
+            "prediction": "Healthy",
+            "confidence": 0.98,
+            "all_predictions": [
+                {"label": "Healthy", "confidence": 0.98},
+                {"label": "Black Spot", "confidence": 0.01},
+                {"label": "Shriveled", "confidence": 0.005},
+                {"label": "Damaged", "confidence": 0.005},
+            ],
+            "timestamp": "2026-03-07T08:00:00Z",
+        }
+        assert response["model"] == "walnut-defect-classifier"
+        assert 0 <= response["confidence"] <= 1
+        assert len(response["all_predictions"]) == 4
+
+
+class TestWalnutRancidityPredictor:
+    """Test walnut rancidity prediction"""
+
+    def test_rancidity_arrhenius_kinetics(self):
+        """Arrhenius kinetics should produce valid rate constant"""
+        import math
+        A = 1.5e12
+        Ea = 80000
+        R = 8.314
+        T_kelvin = 25 + 273.15  # 25°C
+        k = A * math.exp(-Ea / (R * T_kelvin))
+        assert k > 0
+        assert k < 1  # rate constant should be small for real conditions
+
+    def test_rancidity_probability_range(self):
+        """Rancidity probability should be between 0 and 1"""
+        import math
+        for pv in [0.1, 1.0, 3.0, 5.0, 8.0, 15.0]:
+            prob = 1.0 / (1.0 + math.exp(-(pv - 5)))
+            assert 0 <= prob <= 1
+
+    def test_rancidity_threshold(self):
+        """PV > 5 should give rancidity probability > 0.5"""
+        import math
+        pv_safe = 2.0
+        pv_rancid = 8.0
+        prob_safe = 1.0 / (1.0 + math.exp(-(pv_safe - 5)))
+        prob_rancid = 1.0 / (1.0 + math.exp(-(pv_rancid - 5)))
+        assert prob_safe < 0.5
+        assert prob_rancid > 0.5
+
+    def test_risk_level_classification(self):
+        """Risk levels should classify correctly"""
+        def classify(prob):
+            if prob < 0.30:
+                return "LOW"
+            elif prob < 0.70:
+                return "MEDIUM"
+            else:
+                return "HIGH"
+        
+        assert classify(0.1) == "LOW"
+        assert classify(0.5) == "MEDIUM"
+        assert classify(0.8) == "HIGH"
+
+    def test_rancidity_input_validation(self):
+        """Should validate input ranges"""
+        valid_inputs = {
+            "storage_days": 30,
+            "temperature": 25,
+            "humidity": 60,
+            "moisture": 5,
+        }
+        assert 0 <= valid_inputs["storage_days"] <= 365
+        assert -10 <= valid_inputs["temperature"] <= 50
+        assert 0 <= valid_inputs["humidity"] <= 100
+        assert 0 <= valid_inputs["moisture"] <= 20
+
+
+class TestApplePricePredictor:
+    """Test apple price prediction"""
+
+    def test_apple_varieties(self):
+        """Should have correct apple varieties"""
+        varieties = ["Shimla", "Kinnauri", "Royal Delicious", "Golden Delicious", "Maharaji"]
+        assert len(varieties) == 5
+        assert "Kinnauri" in varieties
+
+    def test_apple_regions(self):
+        """Should have correct Indian regions"""
+        regions = ["Himachal Pradesh", "Jammu & Kashmir", "Uttarakhand",
+                    "Arunachal Pradesh", "Nagaland"]
+        assert len(regions) == 5
+        assert "Himachal Pradesh" in regions
+
+    def test_storage_cost_calculation(self):
+        """Storage cost should be ₹0.75/kg/day"""
+        storage_cost_per_day = 0.75
+        storage_cost_7d = storage_cost_per_day * 7
+        assert storage_cost_7d == pytest.approx(5.25)
+
+    def test_sell_store_decision(self):
+        """SELL/STORE decision should be based on breakeven"""
+        current_price = 120.0
+        storage_cost_7d = 5.25
+        breakeven = current_price + storage_cost_7d
+        
+        predicted_high = 130.0
+        predicted_low = 122.0
+        
+        assert predicted_high > breakeven  # should STORE
+        assert predicted_low < breakeven   # should SELL
+
+    def test_seasonal_adjustment(self):
+        """Seasonal adjustments should be applied for Indian market"""
+        # Harvest season (Jul-Oct): discount
+        # Summer scarcity (Apr-Jun): premium
+        harvest_months = [7, 8, 9, 10]
+        scarcity_months = [4, 5, 6]
+        
+        for m in harvest_months:
+            assert 7 <= m <= 10
+        for m in scarcity_months:
+            assert 4 <= m <= 6
+
+    def test_apple_price_response_format(self):
+        """Apple price response should have correct fields"""
+        expected_keys = {"model", "predicted_price_7d", "recommendation",
+                         "current_price", "storage_cost_7d", "breakeven_price",
+                         "currency", "confidence", "advisory", "timestamp"}
+        response = {
+            "model": "apple-price-predictor",
+            "predicted_price_7d": 127.5,
+            "recommendation": "STORE",
+            "current_price": 120.0,
+            "storage_cost_7d": 5.25,
+            "breakeven_price": 125.25,
+            "currency": "INR",
+            "confidence": "hybrid seasonal+trend model",
+            "advisory": "Predicted price in 7 days: ₹127.5/kg. Store for better returns.",
+            "timestamp": "2026-03-07T08:00:00Z",
+        }
+        assert set(response.keys()) == expected_keys
+        assert response["currency"] == "INR"
+        assert response["recommendation"] in ["SELL", "STORE"]
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

ai-backend/tests/test_models.py

@@ -0,0 +1,328 @@
+"""Unit tests for model manager and prediction functions.
+
+Tests each model's prediction functionality with sample inputs.
+Uses mocked models to avoid heavy downloads and ensure fast, deterministic tests.
+"""
+import pytest
+import numpy as np
+from unittest.mock import patch, MagicMock
+import sys
+import os
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from src.models import manager
+
+# Check if torchvision is available
+try:
+    import torchvision
+    TORCHVISION_AVAILABLE = True
+except ImportError:
+    TORCHVISION_AVAILABLE = False
+
+
+class TestModelManager:
+    """Tests for model manager initialization and caching."""
+    
+    def test_get_device(self):
+        """Test device detection."""
+        device = manager.get_device()
+        assert device is not None
+        assert str(device) in ['cpu', 'cuda']
+    
+    def test_model_cache_empty_initially(self):
+        """Test that model cache starts empty."""
+        manager._model_cache.clear()
+        assert len(manager._model_cache) == 0
+    
+    def test_is_model_loaded(self):
+        """Test model loaded status check."""
+        manager._model_cache.clear()
+        assert not manager.is_model_loaded('crop_model')
+        
+        manager._model_cache['crop_model'] = MagicMock()
+        assert manager.is_model_loaded('crop_model')
+    
+    def test_get_model_status(self):
+        """Test getting status of all models."""
+        manager._model_cache.clear()
+        status = manager.get_model_status()
+        
+        assert isinstance(status, dict)
+        assert 'disease_model' in status
+        assert 'crop_model' in status
+        assert 'fertilizer_classifier' in status
+        assert 'loan_price_model' in status
+        assert 'loan_approval_model' in status
+
+
+class TestCropRecommendation:
+    """Tests for crop recommendation model."""
+    
+    def test_predict_crop_with_valid_input(self, mock_crop_model):
+        """Test crop prediction with valid input."""
+        # Setup mocks in cache
+        manager._model_cache['crop_model'] = mock_crop_model['model']
+        manager._model_cache['crop_standard_scaler'] = mock_crop_model['standard_scaler']
+        manager._model_cache['crop_minmax_scaler'] = mock_crop_model['minmax_scaler']
+        
+        # Create sample features
+        features = np.array([[50, 30, 40, 28, 65, 6.5, 200]])
+        
+        # Make prediction
+        result = manager.predict_crop(features)
+        
+        # Assertions
+        assert isinstance(result, int)
+        assert result == 1  # Mock returns 1 for "Rice"
+    
+    def test_predict_crop_without_models_raises_error(self):
+        """Test that prediction fails gracefully when models not loaded."""
+        manager._model_cache.clear()
+        
+        # Ensure models are explicitly None to avoid auto-loading
+        manager._model_cache['crop_model'] = None
+        manager._model_cache['crop_standard_scaler'] = None
+        manager._model_cache['crop_minmax_scaler'] = None
+        
+        features = np.array([[50, 30, 40, 28, 65, 6.5, 200]])
+        
+        with pytest.raises(RuntimeError, match="Crop recommendation models not loaded"):
+            manager.predict_crop(features)
+    
+    def test_crop_prediction_calls_scalers(self, mock_crop_model):
+        """Test that crop prediction uses both scalers."""
+        manager._model_cache['crop_model'] = mock_crop_model['model']
+        manager._model_cache['crop_standard_scaler'] = mock_crop_model['standard_scaler']
+        manager._model_cache['crop_minmax_scaler'] = mock_crop_model['minmax_scaler']
+        
+        features = np.array([[50, 30, 40, 28, 65, 6.5, 200]])
+        manager.predict_crop(features)
+        
+        # Verify scalers were called
+        mock_crop_model['minmax_scaler'].transform.assert_called_once()
+        mock_crop_model['standard_scaler'].transform.assert_called_once()
+        mock_crop_model['model'].predict.assert_called_once()
+
+
+class TestFertilizerPrediction:
+    """Tests for fertilizer prediction model."""
+    
+    def test_predict_fertilizer_with_valid_input(self, mock_fertilizer_model):
+        """Test fertilizer prediction with valid input."""
+        manager._model_cache['fertilizer_classifier'] = mock_fertilizer_model['classifier']
+        manager._model_cache['fertilizer_label_encoder'] = mock_fertilizer_model['label_encoder']
+        
+        features = np.array([[28, 65, 45, 2, 10, 50, 40, 30]])
+        
+        result = manager.predict_fertilizer(features)
+        
+        assert isinstance(result, str)
+        assert result == "Urea"
+    
+    def test_predict_fertilizer_without_models_raises_error(self):
+        """Test that prediction fails when models not loaded."""
+        manager._model_cache.clear()
+        
+        # Ensure models are explicitly None to avoid auto-loading
+        manager._model_cache['fertilizer_classifier'] = None
+        manager._model_cache['fertilizer_label_encoder'] = None
+        
+        features = np.array([[28, 65, 45, 2, 10, 50, 40, 30]])
+        
+        with pytest.raises(RuntimeError, match="Fertilizer prediction models not loaded"):
+            manager.predict_fertilizer(features)
+
+
+class TestDiseasePrediction:
+    """Tests for disease detection model."""
+    
+    @pytest.mark.skipif(not TORCHVISION_AVAILABLE, reason="torchvision not installed")
+    @patch('model_utils.predict')
+    def test_predict_disease_with_valid_image(self, mock_predict, mock_disease_model, mock_pil_image):
+        """Test disease prediction with valid image."""
+        if mock_pil_image is None:
+            pytest.skip("PIL not available")
+        
+        model, labels, remedies = mock_disease_model
+        manager._model_cache['disease_model'] = model
+        manager._model_cache['disease_labels'] = labels
+        manager._model_cache['disease_remedies'] = remedies
+        
+        # Mock the predict function to return expected values
+        mock_predict.return_value = ("bacterial_blight", 0.95, [
+            ("bacterial_blight", 0.95),
+            ("leaf_spot", 0.03),
+            ("rust", 0.02)
+        ])
+        
+        label, confidence, topk = manager.predict_disease(mock_pil_image, topk=3)
+        
+        assert label == "bacterial_blight"
+        assert confidence == 0.95
+        assert len(topk) == 3
+    
+    @pytest.mark.skipif(not TORCHVISION_AVAILABLE, reason="torchvision not installed")
+    def test_predict_disease_without_model_raises_error(self, mock_pil_image):
+        """Test that prediction fails when model not loaded."""
+        if mock_pil_image is None:
+            pytest.skip("PIL not available")
+        
+        manager._model_cache.clear()
+        # Ensure models are explicitly None to avoid auto-loading
+        manager._model_cache['disease_model'] = None
+        manager._model_cache['disease_labels'] = []
+        
+        with pytest.raises(RuntimeError, match="Disease model not loaded"):
+            manager.predict_disease(mock_pil_image)
+    
+    def test_get_disease_remedy(self, mock_disease_model):
+        """Test getting remedy for a disease."""
+        _, _, remedies = mock_disease_model
+        manager._model_cache['disease_remedies'] = remedies
+        
+        remedy = manager.get_disease_remedy("bacterial_blight")
+        assert remedy == "Apply copper-based fungicide"
+        
+        # Test non-existent disease
+        remedy = manager.get_disease_remedy("unknown_disease")
+        assert remedy is None
+
+
+class TestLoanPrediction:
+    """Tests for loan prediction models."""
+    
+    def test_loan_models_in_cache(self, mock_loan_models):
+        """Test that loan models can be cached."""
+        manager._model_cache['loan_price_model'] = mock_loan_models['price_model']
+        manager._model_cache['loan_approval_model'] = mock_loan_models['approval_model']
+        
+        assert manager.is_model_loaded('loan_price_model')
+        assert manager.is_model_loaded('loan_approval_model')
+    
+    def test_get_loan_model(self, mock_loan_models):
+        """Test retrieving loan models from cache."""
+        manager._model_cache['loan_price_model'] = mock_loan_models['price_model']
+        
+        model = manager.get_model('loan_price_model', auto_load=False)
+        assert model is not None
+        assert model == mock_loan_models['price_model']
+
+
+class TestBinaryCompatibilityHandling:
+    """Tests explicit failure behavior when sklearn/scipy binaries are incompatible."""
+
+    def test_fertilizer_load_raises_on_numpy_binary_error(self):
+        from src.models import manager
+        manager._model_cache.clear()
+
+        with patch('src.models.manager._download_from_hf', return_value='/tmp/mock.pkl'), \
+             patch('builtins.open', side_effect=ImportError('numpy.core.multiarray failed to import')):
+            with pytest.raises(RuntimeError, match="NumPy/SciPy binary compatibility"):
+                manager.load_fertilizer_models()
+
+    def test_crop_load_raises_on_array_api_error(self):
+        from src.models import manager
+        manager._model_cache.clear()
+
+        with patch('src.models.manager.joblib.load', side_effect=AttributeError('_ARRAY_API not found')):
+            with pytest.raises(RuntimeError, match="NumPy/SciPy binary compatibility"):
+                manager.load_crop_recommendation_models()
+
+    def test_loan_load_raises_on_numpy_binary_error(self):
+        from src.models import manager
+        manager._model_cache.clear()
+
+        with patch('src.models.manager.joblib.load', side_effect=ImportError('numpy.core.multiarray failed to import')):
+            with pytest.raises(RuntimeError, match="NumPy/SciPy binary compatibility"):
+                manager.load_loan_models()
+
+
+@pytest.mark.parametrize("model_type,expected_keys", [
+    ("crop", ["model", "standard_scaler", "minmax_scaler"]),
+    ("fertilizer", ["classifier", "label_encoder"]),
+    ("loan", ["price_model", "approval_model"]),
+])
+def test_model_loading_functions(model_type, expected_keys):
+    """Parametrized test for model loading functions.
+    
+    Note: This test uses real HF downloads and is slow.
+    It should be mocked or skipped in CI without HF access.
+    """
+    pytest.skip("Skipping real HF download tests - use mocks instead")
+    
+    if model_type == "crop":
+        models = manager.load_crop_recommendation_models()
+    elif model_type == "fertilizer":
+        models = manager.load_fertilizer_models()
+    elif model_type == "loan":
+        models = manager.load_loan_models()
+    
+    assert isinstance(models, dict)
+    for key in expected_keys:
+        assert key in models
+        assert models[key] is not None
+
+
+class TestModelInitialization:
+    """Tests for model initialization."""
+    
+    @patch('src.models.manager.load_disease_model')
+    @patch('src.models.manager.load_crop_recommendation_models')
+    @patch('src.models.manager.load_fertilizer_models')
+    @patch('src.models.manager.load_loan_models')
+    def test_initialize_models_all(
+        self, mock_loan, mock_fert, mock_crop, mock_disease
+    ):
+        """Test initializing all models."""
+        # Setup mocks
+        mock_disease.return_value = (MagicMock(), ["label1"], {"label1": "remedy"})
+        mock_crop.return_value = {
+            "model": MagicMock(),
+            "standard_scaler": MagicMock(),
+            "minmax_scaler": MagicMock()
+        }
+        mock_fert.return_value = {
+            "classifier": MagicMock(),
+            "label_encoder": MagicMock()
+        }
+        mock_loan.return_value = {
+            "price_model": MagicMock(),
+            "approval_model": MagicMock()
+        }
+        
+        manager._model_cache.clear()
+        manager.initialize_models(load_all=True)
+        
+        # Verify all loaders were called
+        mock_disease.assert_called_once()
+        mock_crop.assert_called_once()
+        mock_fert.assert_called_once()
+        mock_loan.assert_called_once()
+        
+        # Verify models are in cache
+        assert 'disease_model' in manager._model_cache
+        assert 'crop_model' in manager._model_cache
+        assert 'fertilizer_classifier' in manager._model_cache
+        assert 'loan_price_model' in manager._model_cache
+    
+    def test_initialize_models_lazy(self):
+        """Test lazy initialization (don't load all at startup)."""
+        manager._model_cache.clear()
+        manager.initialize_models(load_all=False)
+        
+        # Cache should remain empty with lazy loading
+        assert len(manager._model_cache) == 0
+    
+    @patch('src.models.manager.load_disease_model')
+    def test_initialize_handles_load_failure(self, mock_disease):
+        """Test that initialization continues even if a model fails to load."""
+        mock_disease.side_effect = Exception("HF Hub connection failed")
+        
+        manager._model_cache.clear()
+        # Should not raise, just log error
+        manager.initialize_models(load_all=True)
+        
+        # Disease model should be None in cache
+        assert manager._model_cache.get('disease_model') is None
+        assert manager._model_cache.get('disease_labels') == []

backend/Dockerfile

@@ -0,0 +1,55 @@
+# Backend Dockerfile (HF Spaces compatible)
+
+FROM node:22-alpine as base
+
+WORKDIR /app
+
+# Install dependencies for native modules + wget for healthcheck
+RUN apk add --no-cache python3 make g++ wget
+
+# Copy package files
+COPY package*.json ./
+
+# ========================
+# Development stage
+# ========================
+FROM base as development
+RUN npm ci
+COPY . .
+EXPOSE 7860
+CMD ["npm", "run", "dev"]
+
+# ========================
+# Production stage
+# ========================
+FROM base as production
+
+ENV NODE_ENV=production
+
+# Install production dependencies only
+RUN npm ci --omit=dev
+
+# Copy source files
+COPY . .
+
+# Create non-root user (uid 1000 required by HF Spaces)
+RUN set -ex && \
+    if ! getent group 1000 > /dev/null 2>&1; then \
+      addgroup -g 1000 -S nodejs; \
+    fi && \
+    GROUP_NAME=$(getent group 1000 | cut -d: -f1) && \
+    if ! getent passwd 1000 > /dev/null 2>&1; then \
+      adduser -D -u 1000 -G ${GROUP_NAME} nodejs; \
+    fi && \
+    chown -R 1000:1000 /app
+
+USER 1000
+
+# EXPOSE is informational (HF ignores it but safe to keep)
+EXPOSE 7860
+
+# Healthcheck probes backend on port 7860
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://127.0.0.1:7860/health || exit 1
+
+CMD ["node", "server.js"]

backend/FIREBASE_FIRESTORE_SETUP.md

@@ -0,0 +1,34 @@
+# Firebase Auth and Firestore REST setup
+
+AgroMind uses **Firebase Authentication** for identity and **Cloud Firestore** for application data. The backend does not use MongoDB, a custom JWT secret, `firebase-admin`, a service-account JSON file, Google Application Default Credentials, or Google Cloud IAM.
+
+## Required deployment configuration
+
+Set the following Hugging Face Space secrets:
+
+| Secret | Value |
+|---|---|
+| `FIREBASE_PROJECT_ID` | `agromind-a62c1` |
+| `FIREBASE_API_KEY` | The Firebase Web API key from the Firebase app configuration |
+
+The API key is used only to call Firebase Identity Toolkit's `accounts:lookup` endpoint. The browser sends a short-lived Firebase ID token to the backend. Firestore REST requests use that same user token as a bearer token, so Firestore Security Rules—not a privileged server credential—authorize the data operation.
+
+The frontend Vercel deployment continues to use the normal `VITE_FIREBASE_*` Web SDK configuration. Never place service-account JSON, private keys, GitHub tokens, or Hugging Face write tokens in the repository or in `VITE_*` variables.
+
+## Authentication and persistence flow
+
+The browser signs users in with Firebase Auth using email/password or Google. `newRequest` attaches the current Firebase ID token to protected API calls. The backend verifies that token with Firebase Identity Toolkit, attaches the verified Firebase UID to the request, and carries the token into the REST-backed Firestore compatibility adapter. The adapter preserves the existing model surface while applying Firestore rules to each read and write.
+
+The browser stores no custom JWT. A tab-scoped session record keeps the Profile login time stable across refreshes and is cleared on explicit logout or when the tab is closed. The Profile page also reads and upserts the user's `users/{uid}` document with the Firebase Web SDK repository.
+
+## Firestore data model
+
+Former application models remain top-level Firestore collections such as `users`, `appointments`, `crops`, `farmerDetails`, `tasks`, `records`, `posts`, `notifications`, `milletListings`, `oilPalmProfiles`, and feature-specific collections. User references are Firebase Auth UIDs or Firestore document IDs; passwords are never stored.
+
+## Deployment checklist
+
+1. Add `FIREBASE_PROJECT_ID` and `FIREBASE_API_KEY` to the Hugging Face Space secrets.
+2. Deploy the rules in `firestore.rules` using the Firebase CLI or the Firebase Console's Rules editor.
+3. Confirm the backend health endpoint returns `services.firestore = "user-token-rest"` and does not attempt a startup Firestore connection.
+4. Confirm a signed-in user can load Profile and perform one representative protected read and write.
+5. Confirm an unauthenticated request receives HTTP 401 and a user cannot write another user's owner-scoped document.

backend/contracts/AgroExchange.sol

@@ -0,0 +1,383 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+/**
+ * @title AgroExchange
+ * @dev Escrow contract for agricultural commodity transactions
+ * @notice This contract facilitates secure transactions between farmers and buyers
+ */
+contract AgroExchange {
+    // State variables
+    address public owner;
+    uint256 public transactionCount;
+    uint256 public platformFeePercent; // in basis points (100 = 1%)
+    
+    // Structs
+    struct Transaction {
+        uint256 id;
+        address payable seller;
+        address payable buyer;
+        uint256 amount;
+        string listingId; // MongoDB listing ID
+        TransactionState state;
+        uint256 createdAt;
+        uint256 releasedAt;
+        string productType;
+        uint256 quantityKg;
+    }
+    
+    enum TransactionState {
+        Created,
+        Funded,
+        Delivered,
+        Completed,
+        Disputed,
+        Refunded,
+        Cancelled
+    }
+    
+    // Mappings
+    mapping(uint256 => Transaction) public transactions;
+    mapping(address => uint256[]) public userTransactions;
+    mapping(string => uint256) public listingToTransaction;
+    
+    // Events
+    event TransactionCreated(
+        uint256 indexed transactionId,
+        address indexed seller,
+        address indexed buyer,
+        uint256 amount,
+        string listingId
+    );
+    
+    event TransactionFunded(
+        uint256 indexed transactionId,
+        address indexed buyer,
+        uint256 amount
+    );
+    
+    event DeliveryConfirmed(
+        uint256 indexed transactionId,
+        address indexed buyer
+    );
+    
+    event FundsReleased(
+        uint256 indexed transactionId,
+        address indexed seller,
+        uint256 amount
+    );
+    
+    event TransactionDisputed(
+        uint256 indexed transactionId,
+        address indexed disputer,
+        string reason
+    );
+    
+    event DisputeResolved(
+        uint256 indexed transactionId,
+        address indexed winner,
+        uint256 amount
+    );
+    
+    event TransactionRefunded(
+        uint256 indexed transactionId,
+        address indexed buyer,
+        uint256 amount
+    );
+    
+    event TransactionCancelled(
+        uint256 indexed transactionId
+    );
+    
+    // Modifiers
+    modifier onlyOwner() {
+        require(msg.sender == owner, "Only owner can call this function");
+        _;
+    }
+    
+    modifier onlySeller(uint256 _transactionId) {
+        require(
+            msg.sender == transactions[_transactionId].seller,
+            "Only seller can call this function"
+        );
+        _;
+    }
+    
+    modifier onlyBuyer(uint256 _transactionId) {
+        require(
+            msg.sender == transactions[_transactionId].buyer,
+            "Only buyer can call this function"
+        );
+        _;
+    }
+    
+    modifier onlyParties(uint256 _transactionId) {
+        require(
+            msg.sender == transactions[_transactionId].seller ||
+            msg.sender == transactions[_transactionId].buyer,
+            "Only transaction parties can call this function"
+        );
+        _;
+    }
+    
+    modifier inState(uint256 _transactionId, TransactionState _state) {
+        require(
+            transactions[_transactionId].state == _state,
+            "Transaction is not in the required state"
+        );
+        _;
+    }
+    
+    // Constructor
+    constructor() {
+        owner = msg.sender;
+        platformFeePercent = 100; // 1% platform fee
+        transactionCount = 0;
+    }
+    
+    /**
+     * @dev Create a new escrow transaction
+     * @param _seller Address of the seller
+     * @param _listingId MongoDB listing ID for reference
+     * @param _productType Type of product being sold
+     * @param _quantityKg Quantity in kilograms
+     */
+    function createTransaction(
+        address payable _seller,
+        string memory _listingId,
+        string memory _productType,
+        uint256 _quantityKg
+    ) external payable returns (uint256) {
+        require(_seller != address(0), "Invalid seller address");
+        require(_seller != msg.sender, "Seller cannot be buyer");
+        require(msg.value > 0, "Transaction amount must be greater than 0");
+        require(bytes(_listingId).length > 0, "Listing ID required");
+        require(listingToTransaction[_listingId] == 0, "Transaction already exists for this listing");
+        
+        transactionCount++;
+        uint256 transactionId = transactionCount;
+        
+        transactions[transactionId] = Transaction({
+            id: transactionId,
+            seller: _seller,
+            buyer: payable(msg.sender),
+            amount: msg.value,
+            listingId: _listingId,
+            state: TransactionState.Funded,
+            createdAt: block.timestamp,
+            releasedAt: 0,
+            productType: _productType,
+            quantityKg: _quantityKg
+        });
+        
+        userTransactions[_seller].push(transactionId);
+        userTransactions[msg.sender].push(transactionId);
+        listingToTransaction[_listingId] = transactionId;
+        
+        emit TransactionCreated(transactionId, _seller, msg.sender, msg.value, _listingId);
+        emit TransactionFunded(transactionId, msg.sender, msg.value);
+        
+        return transactionId;
+    }
+    
+    /**
+     * @dev Buyer confirms delivery and releases funds to seller
+     * @param _transactionId ID of the transaction
+     */
+    function confirmDelivery(uint256 _transactionId) 
+        external 
+        onlyBuyer(_transactionId)
+        inState(_transactionId, TransactionState.Funded)
+    {
+        Transaction storage txn = transactions[_transactionId];
+        
+        txn.state = TransactionState.Completed;
+        txn.releasedAt = block.timestamp;
+        
+        // Calculate platform fee
+        uint256 platformFee = (txn.amount * platformFeePercent) / 10000;
+        uint256 sellerAmount = txn.amount - platformFee;
+        
+        // Transfer funds
+        txn.seller.transfer(sellerAmount);
+        payable(owner).transfer(platformFee);
+        
+        emit DeliveryConfirmed(_transactionId, msg.sender);
+        emit FundsReleased(_transactionId, txn.seller, sellerAmount);
+    }
+    
+    /**
+     * @dev Raise a dispute for a transaction
+     * @param _transactionId ID of the transaction
+     * @param _reason Reason for dispute
+     */
+    function raiseDispute(uint256 _transactionId, string memory _reason)
+        external
+        onlyParties(_transactionId)
+        inState(_transactionId, TransactionState.Funded)
+    {
+        transactions[_transactionId].state = TransactionState.Disputed;
+        
+        emit TransactionDisputed(_transactionId, msg.sender, _reason);
+    }
+    
+    /**
+     * @dev Resolve a dispute (only owner/arbitrator can call)
+     * @param _transactionId ID of the transaction
+     * @param _refundBuyer If true, refund buyer; if false, release to seller
+     */
+    function resolveDispute(uint256 _transactionId, bool _refundBuyer)
+        external
+        onlyOwner
+        inState(_transactionId, TransactionState.Disputed)
+    {
+        Transaction storage txn = transactions[_transactionId];
+        
+        if (_refundBuyer) {
+            txn.state = TransactionState.Refunded;
+            txn.buyer.transfer(txn.amount);
+            emit DisputeResolved(_transactionId, txn.buyer, txn.amount);
+            emit TransactionRefunded(_transactionId, txn.buyer, txn.amount);
+        } else {
+            txn.state = TransactionState.Completed;
+            txn.releasedAt = block.timestamp;
+            
+            uint256 platformFee = (txn.amount * platformFeePercent) / 10000;
+            uint256 sellerAmount = txn.amount - platformFee;
+            
+            txn.seller.transfer(sellerAmount);
+            payable(owner).transfer(platformFee);
+            
+            emit DisputeResolved(_transactionId, txn.seller, sellerAmount);
+            emit FundsReleased(_transactionId, txn.seller, sellerAmount);
+        }
+    }
+    
+    /**
+     * @dev Cancel a transaction (only if not yet funded or both parties agree)
+     * @param _transactionId ID of the transaction
+     */
+    function cancelTransaction(uint256 _transactionId)
+        external
+        onlyParties(_transactionId)
+    {
+        Transaction storage txn = transactions[_transactionId];
+        
+        require(
+            txn.state == TransactionState.Created ||
+            txn.state == TransactionState.Funded,
+            "Cannot cancel transaction in current state"
+        );
+        
+        if (txn.state == TransactionState.Funded) {
+            // Refund buyer
+            txn.state = TransactionState.Cancelled;
+            txn.buyer.transfer(txn.amount);
+            emit TransactionRefunded(_transactionId, txn.buyer, txn.amount);
+        } else {
+            txn.state = TransactionState.Cancelled;
+        }
+        
+        emit TransactionCancelled(_transactionId);
+    }
+    
+    /**
+     * @dev Auto-release funds after timeout (14 days)
+     * @param _transactionId ID of the transaction
+     */
+    function autoRelease(uint256 _transactionId)
+        external
+        inState(_transactionId, TransactionState.Funded)
+    {
+        Transaction storage txn = transactions[_transactionId];
+        
+        require(
+            block.timestamp >= txn.createdAt + 14 days,
+            "Auto-release period not yet reached"
+        );
+        
+        txn.state = TransactionState.Completed;
+        txn.releasedAt = block.timestamp;
+        
+        uint256 platformFee = (txn.amount * platformFeePercent) / 10000;
+        uint256 sellerAmount = txn.amount - platformFee;
+        
+        txn.seller.transfer(sellerAmount);
+        payable(owner).transfer(platformFee);
+        
+        emit FundsReleased(_transactionId, txn.seller, sellerAmount);
+    }
+    
+    // View functions
+    
+    /**
+     * @dev Get transaction details
+     * @param _transactionId ID of the transaction
+     */
+    function getTransaction(uint256 _transactionId)
+        external
+        view
+        returns (Transaction memory)
+    {
+        require(_transactionId > 0 && _transactionId <= transactionCount, "Invalid transaction ID");
+        return transactions[_transactionId];
+    }
+    
+    /**
+     * @dev Get user's transactions
+     * @param _user Address of the user
+     */
+    function getUserTransactions(address _user)
+        external
+        view
+        returns (uint256[] memory)
+    {
+        return userTransactions[_user];
+    }
+    
+    /**
+     * @dev Get transaction ID by listing ID
+     * @param _listingId MongoDB listing ID
+     */
+    function getTransactionByListing(string memory _listingId)
+        external
+        view
+        returns (uint256)
+    {
+        return listingToTransaction[_listingId];
+    }
+    
+    /**
+     * @dev Get contract balance
+     */
+    function getContractBalance() external view returns (uint256) {
+        return address(this).balance;
+    }
+    
+    // Admin functions
+    
+    /**
+     * @dev Update platform fee (only owner)
+     * @param _newFeePercent New fee in basis points
+     */
+    function updatePlatformFee(uint256 _newFeePercent) external onlyOwner {
+        require(_newFeePercent <= 500, "Fee cannot exceed 5%");
+        platformFeePercent = _newFeePercent;
+    }
+    
+    /**
+     * @dev Transfer ownership (only owner)
+     * @param _newOwner Address of new owner
+     */
+    function transferOwnership(address _newOwner) external onlyOwner {
+        require(_newOwner != address(0), "Invalid address");
+        owner = _newOwner;
+    }
+    
+    /**
+     * @dev Emergency withdraw (only owner, for stuck funds)
+     */
+    function emergencyWithdraw() external onlyOwner {
+        payable(owner).transfer(address(this).balance);
+    }
+}

backend/contracts/hardhat.config.js

@@ -0,0 +1,35 @@
+require("@nomicfoundation/hardhat-toolbox");
+require("dotenv").config();
+
+/** @type import('hardhat/config').HardhatUserConfig */
+module.exports = {
+  solidity: {
+    version: "0.8.19",
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 200,
+      },
+    },
+  },
+  networks: {
+    localhost: {
+      url: "http://127.0.0.1:8545",
+    },
+    hardhat: {
+      chainId: 31337,
+    },
+    sepolia: {
+      url: process.env.BLOCKCHAIN_RPC_URL || "",
+      accounts: process.env.BLOCKCHAIN_PRIVATE_KEY
+        ? [process.env.BLOCKCHAIN_PRIVATE_KEY]
+        : [],
+    },
+  },
+  paths: {
+    sources: "./",
+    tests: "./test",
+    cache: "./cache",
+    artifacts: "./artifacts",
+  },
+};

backend/contracts/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "agromind-contracts",
+  "version": "1.0.0",
+  "description": "Smart contracts for AgroMind escrow and transactions",
+  "scripts": {
+    "compile": "npx hardhat compile",
+    "test": "npx hardhat test",
+    "deploy:local": "npx hardhat run scripts/deploy.js --network localhost",
+    "deploy:sepolia": "npx hardhat run scripts/deploy.js --network sepolia",
+    "node": "npx hardhat node"
+  },
+  "devDependencies": {
+    "@nomicfoundation/hardhat-toolbox": "^4.0.0",
+    "hardhat": "^2.19.0"
+  },
+  "dependencies": {
+    "ethers": "^6.9.0"
+  }
+}

backend/contracts/scripts/deploy.js

@@ -0,0 +1,40 @@
+const { ethers } = require("hardhat");
+
+async function main() {
+  console.log("Deploying AgroExchange contract...");
+  
+  const [deployer] = await ethers.getSigners();
+  console.log("Deploying with account:", deployer.address);
+  
+  const balance = await ethers.provider.getBalance(deployer.address);
+  console.log("Account balance:", ethers.formatEther(balance), "ETH");
+  
+  // Deploy contract
+  const AgroExchange = await ethers.getContractFactory("AgroExchange");
+  const agroExchange = await AgroExchange.deploy();
+  
+  await agroExchange.waitForDeployment();
+  
+  const address = await agroExchange.getAddress();
+  console.log("AgroExchange deployed to:", address);
+  
+  // Log deployment info
+  console.log("\n=== Deployment Summary ===");
+  console.log("Contract Address:", address);
+  console.log("Owner:", deployer.address);
+  console.log("Network:", network.name); // eslint-disable-line no-undef
+  console.log("Gas Used:", (await agroExchange.deploymentTransaction().wait()).gasUsed.toString());
+  
+  // Verify contract settings
+  const platformFee = await agroExchange.platformFeePercent();
+  console.log("Platform Fee:", platformFee.toString(), "basis points (", Number(platformFee) / 100, "%)");
+  
+  return address;
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });

backend/contracts/test/AgroExchange.test.js

@@ -0,0 +1,325 @@
+const { expect } = require("chai");
+const { ethers } = require("hardhat");
+
+describe("AgroExchange", function () {
+  let agroExchange;
+  let owner;
+  let seller;
+  let buyer;
+  let addr3;
+  
+  const listingId = "listing123";
+  const productType = "groundnut";
+  const quantityKg = 1000;
+  const transactionAmount = ethers.parseEther("1.0");
+  
+  beforeEach(async function () {
+    [owner, seller, buyer, addr3] = await ethers.getSigners();
+    
+    const AgroExchange = await ethers.getContractFactory("AgroExchange");
+    agroExchange = await AgroExchange.deploy();
+    await agroExchange.waitForDeployment();
+  });
+  
+  describe("Deployment", function () {
+    it("Should set the right owner", async function () {
+      expect(await agroExchange.owner()).to.equal(owner.address);
+    });
+    
+    it("Should have correct initial platform fee", async function () {
+      expect(await agroExchange.platformFeePercent()).to.equal(100); // 1%
+    });
+    
+    it("Should have zero transaction count initially", async function () {
+      expect(await agroExchange.transactionCount()).to.equal(0);
+    });
+  });
+  
+  describe("Transaction Creation", function () {
+    it("Should create a transaction successfully", async function () {
+      await expect(
+        agroExchange.connect(buyer).createTransaction(
+          seller.address,
+          listingId,
+          productType,
+          quantityKg,
+          { value: transactionAmount }
+        )
+      )
+        .to.emit(agroExchange, "TransactionCreated")
+        .withArgs(1, seller.address, buyer.address, transactionAmount, listingId);
+      
+      expect(await agroExchange.transactionCount()).to.equal(1);
+    });
+    
+    it("Should reject if seller is buyer", async function () {
+      await expect(
+        agroExchange.connect(buyer).createTransaction(
+          buyer.address,
+          listingId,
+          productType,
+          quantityKg,
+          { value: transactionAmount }
+        )
+      ).to.be.revertedWith("Seller cannot be buyer");
+    });
+    
+    it("Should reject if amount is zero", async function () {
+      await expect(
+        agroExchange.connect(buyer).createTransaction(
+          seller.address,
+          listingId,
+          productType,
+          quantityKg,
+          { value: 0 }
+        )
+      ).to.be.revertedWith("Transaction amount must be greater than 0");
+    });
+    
+    it("Should reject duplicate listing", async function () {
+      await agroExchange.connect(buyer).createTransaction(
+        seller.address,
+        listingId,
+        productType,
+        quantityKg,
+        { value: transactionAmount }
+      );
+      
+      await expect(
+        agroExchange.connect(addr3).createTransaction(
+          seller.address,
+          listingId,
+          productType,
+          quantityKg,
+          { value: transactionAmount }
+        )
+      ).to.be.revertedWith("Transaction already exists for this listing");
+    });
+  });
+  
+  describe("Delivery Confirmation", function () {
+    beforeEach(async function () {
+      await agroExchange.connect(buyer).createTransaction(
+        seller.address,
+        listingId,
+        productType,
+        quantityKg,
+        { value: transactionAmount }
+      );
+    });
+    
+    it("Should confirm delivery and release funds", async function () {
+      const sellerBalanceBefore = await ethers.provider.getBalance(seller.address);
+      
+      await expect(agroExchange.connect(buyer).confirmDelivery(1))
+        .to.emit(agroExchange, "DeliveryConfirmed")
+        .to.emit(agroExchange, "FundsReleased");
+      
+      const sellerBalanceAfter = await ethers.provider.getBalance(seller.address);
+      
+      // Seller should receive 99% (1% platform fee)
+      const expectedAmount = transactionAmount * BigInt(9900) / BigInt(10000);
+      expect(sellerBalanceAfter - sellerBalanceBefore).to.equal(expectedAmount);
+    });
+    
+    it("Should reject if not buyer", async function () {
+      await expect(
+        agroExchange.connect(seller).confirmDelivery(1)
+      ).to.be.revertedWith("Only buyer can call this function");
+    });
+    
+    it("Should update transaction state to Completed", async function () {
+      await agroExchange.connect(buyer).confirmDelivery(1);
+      
+      const txn = await agroExchange.getTransaction(1);
+      expect(txn.state).to.equal(4); // Completed state
+    });
+  });
+  
+  describe("Disputes", function () {
+    beforeEach(async function () {
+      await agroExchange.connect(buyer).createTransaction(
+        seller.address,
+        listingId,
+        productType,
+        quantityKg,
+        { value: transactionAmount }
+      );
+    });
+    
+    it("Should allow buyer to raise dispute", async function () {
+      await expect(
+        agroExchange.connect(buyer).raiseDispute(1, "Product not as described")
+      )
+        .to.emit(agroExchange, "TransactionDisputed")
+        .withArgs(1, buyer.address, "Product not as described");
+    });
+    
+    it("Should allow seller to raise dispute", async function () {
+      await expect(
+        agroExchange.connect(seller).raiseDispute(1, "Buyer not responding")
+      )
+        .to.emit(agroExchange, "TransactionDisputed")
+        .withArgs(1, seller.address, "Buyer not responding");
+    });
+    
+    it("Should resolve dispute in favor of buyer", async function () {
+      await agroExchange.connect(buyer).raiseDispute(1, "Product not as described");
+      
+      const buyerBalanceBefore = await ethers.provider.getBalance(buyer.address);
+      
+      await expect(agroExchange.connect(owner).resolveDispute(1, true))
+        .to.emit(agroExchange, "DisputeResolved")
+        .to.emit(agroExchange, "TransactionRefunded");
+      
+      const buyerBalanceAfter = await ethers.provider.getBalance(buyer.address);
+      expect(buyerBalanceAfter - buyerBalanceBefore).to.equal(transactionAmount);
+    });
+    
+    it("Should resolve dispute in favor of seller", async function () {
+      await agroExchange.connect(buyer).raiseDispute(1, "Product not as described");
+      
+      const sellerBalanceBefore = await ethers.provider.getBalance(seller.address);
+      
+      await expect(agroExchange.connect(owner).resolveDispute(1, false))
+        .to.emit(agroExchange, "DisputeResolved")
+        .to.emit(agroExchange, "FundsReleased");
+      
+      const sellerBalanceAfter = await ethers.provider.getBalance(seller.address);
+      const expectedAmount = transactionAmount * BigInt(9900) / BigInt(10000);
+      expect(sellerBalanceAfter - sellerBalanceBefore).to.equal(expectedAmount);
+    });
+    
+    it("Should reject dispute resolution from non-owner", async function () {
+      await agroExchange.connect(buyer).raiseDispute(1, "Product not as described");
+      
+      await expect(
+        agroExchange.connect(buyer).resolveDispute(1, true)
+      ).to.be.revertedWith("Only owner can call this function");
+    });
+  });
+  
+  describe("Cancellation", function () {
+    beforeEach(async function () {
+      await agroExchange.connect(buyer).createTransaction(
+        seller.address,
+        listingId,
+        productType,
+        quantityKg,
+        { value: transactionAmount }
+      );
+    });
+    
+    it("Should cancel and refund funded transaction", async function () {
+      const buyerBalanceBefore = await ethers.provider.getBalance(buyer.address);
+      
+      const tx = await agroExchange.connect(buyer).cancelTransaction(1);
+      const receipt = await tx.wait();
+      const gasUsed = receipt.gasUsed * tx.gasPrice;
+      
+      const buyerBalanceAfter = await ethers.provider.getBalance(buyer.address);
+      
+      // Account for gas costs
+      expect(buyerBalanceAfter + gasUsed - buyerBalanceBefore).to.equal(transactionAmount);
+    });
+    
+    it("Should not allow cancellation after dispute", async function () {
+      await agroExchange.connect(buyer).raiseDispute(1, "Issue");
+      
+      await expect(
+        agroExchange.connect(buyer).cancelTransaction(1)
+      ).to.be.revertedWith("Cannot cancel transaction in current state");
+    });
+  });
+  
+  describe("Auto Release", function () {
+    beforeEach(async function () {
+      await agroExchange.connect(buyer).createTransaction(
+        seller.address,
+        listingId,
+        productType,
+        quantityKg,
+        { value: transactionAmount }
+      );
+    });
+    
+    it("Should reject auto-release before timeout", async function () {
+      await expect(
+        agroExchange.autoRelease(1)
+      ).to.be.revertedWith("Auto-release period not yet reached");
+    });
+    
+    it("Should auto-release after timeout", async function () {
+      // Increase time by 14 days
+      await ethers.provider.send("evm_increaseTime", [14 * 24 * 60 * 60]);
+      await ethers.provider.send("evm_mine");
+      
+      const sellerBalanceBefore = await ethers.provider.getBalance(seller.address);
+      
+      await expect(agroExchange.autoRelease(1))
+        .to.emit(agroExchange, "FundsReleased");
+      
+      const sellerBalanceAfter = await ethers.provider.getBalance(seller.address);
+      const expectedAmount = transactionAmount * BigInt(9900) / BigInt(10000);
+      expect(sellerBalanceAfter - sellerBalanceBefore).to.equal(expectedAmount);
+    });
+  });
+  
+  describe("View Functions", function () {
+    beforeEach(async function () {
+      await agroExchange.connect(buyer).createTransaction(
+        seller.address,
+        listingId,
+        productType,
+        quantityKg,
+        { value: transactionAmount }
+      );
+    });
+    
+    it("Should return transaction details", async function () {
+      const txn = await agroExchange.getTransaction(1);
+      expect(txn.seller).to.equal(seller.address);
+      expect(txn.buyer).to.equal(buyer.address);
+      expect(txn.amount).to.equal(transactionAmount);
+      expect(txn.listingId).to.equal(listingId);
+    });
+    
+    it("Should return user transactions", async function () {
+      const buyerTxns = await agroExchange.getUserTransactions(buyer.address);
+      expect(buyerTxns.length).to.equal(1);
+      expect(buyerTxns[0]).to.equal(1);
+      
+      const sellerTxns = await agroExchange.getUserTransactions(seller.address);
+      expect(sellerTxns.length).to.equal(1);
+    });
+    
+    it("Should return transaction by listing ID", async function () {
+      const txnId = await agroExchange.getTransactionByListing(listingId);
+      expect(txnId).to.equal(1);
+    });
+  });
+  
+  describe("Admin Functions", function () {
+    it("Should update platform fee", async function () {
+      await agroExchange.connect(owner).updatePlatformFee(200); // 2%
+      expect(await agroExchange.platformFeePercent()).to.equal(200);
+    });
+    
+    it("Should reject fee update from non-owner", async function () {
+      await expect(
+        agroExchange.connect(buyer).updatePlatformFee(200)
+      ).to.be.revertedWith("Only owner can call this function");
+    });
+    
+    it("Should reject fee above 5%", async function () {
+      await expect(
+        agroExchange.connect(owner).updatePlatformFee(600)
+      ).to.be.revertedWith("Fee cannot exceed 5%");
+    });
+    
+    it("Should transfer ownership", async function () {
+      await agroExchange.connect(owner).transferOwnership(addr3.address);
+      expect(await agroExchange.owner()).to.equal(addr3.address);
+    });
+  });
+});

backend/controllers/appointmentController.js

@@ -0,0 +1,81 @@
+// appointmentController.js
+
+import Appointment from "../models/appointmentModel.js";
+import User from "../models/auth.model.js";
+
+// Booking an appointment
+export const bookAppointment = async (req, res, io) => {
+    try {
+        const { expertId } = req.body;
+        const farmerId = req.userId; // Get farmerId from the token
+
+        const appointment = await Appointment.create({ farmerId, expertId });
+        const expert = await User.findById(expertId);
+
+        if (expert.socketId) {
+            io.to(expert.socketId).emit('appointmentRequest', {
+                appointMentId: appointment._id,
+                farmerId: farmerId,
+            });
+        }
+
+        res.status(200).json({ message: "Appointment request sent to expert" });
+    } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: "An error occurred while booking the appointment" });
+    }
+};
+
+// Accept an appointment
+export const acceptAppointment = async (req, res, io) => {
+    try {
+        const { appointmentId } = req.params;
+        const appointment = await Appointment.findByIdAndUpdate(appointmentId, { status: 'accepted' }, { new: true });
+        if (!appointment) return res.status(404).json({ error: "Appointment not found" });
+
+        io.to(appointment.farmerId.toString()).emit('appointmentAccepted', { appointmentId });
+        res.status(200).json({ message: "Appointment accepted successfully" });
+    } catch (_error) {
+        res.status(500).json({ error: "An error occurred while accepting an appointment" });
+    }
+};
+
+// Decline an appointment
+export const declineAppointment = async (req, res, io) => {
+    try {
+        const { appointmentId } = req.params;
+        const appointment = await Appointment.findByIdAndUpdate(appointmentId, { status: 'declined' }, { new: true });
+        if (!appointment) return res.status(404).json({ error: "Appointment not found" });
+
+        io.to(appointment.farmerId.toString()).emit('appointmentDeclined', { appointmentId });
+        res.status(200).json({ message: "Appointment declined successfully" });
+    } catch (_error) {
+        res.status(500).json({ error: "An error occurred while declining the appointment" });
+    }
+};
+
+// Get all appointments for expert
+export const getAppointmentsForExpert = async (req, res) => {
+    try {
+        const expertId = req.userId; // Get expertId from the token
+        const appointments = await Appointment.find({ expertId }).populate('farmerId', 'name'); // Assuming 'farmerId' contains the farmer's data like name
+        if (!appointments) return res.status(404).json({ error: "No appointments found for this expert" });
+
+        res.status(200).json(appointments);
+    } catch (_error) {
+        res.status(500).json({ error: "An error occurred while fetching appointments for expert" });
+    }
+};
+
+// Get all appointments for farmer
+export const getAppointmentsForFarmer = async (req, res) => {
+    try {
+        const farmerId = req.userId; // Get farmerId from the token
+        const appointments = await Appointment.find({ farmerId }).populate('expertId', 'name'); // Assuming 'expertId' contains the expert's data like name
+        if (!appointments) return res.status(404).json({ error: "No appointments found for this farmer" });
+
+        res.status(200).json(appointments);
+    } catch (_error) {
+        res.status(500).json({ error: "An error occurred while fetching appointments for farmer" });
+    }
+};

backend/controllers/authController.js

@@ -0,0 +1,73 @@
+import User from "../models/auth.model.js";
+
+const normalizeEmail = (email) => email?.trim().toLowerCase() || null;
+
+const profileFromRequest = (req) => ({
+  _id: req.userId,
+  id: req.userId,
+  firebaseUid: req.userId,
+  email: normalizeEmail(req.userEmail || req.firebaseUser?.email),
+  name: req.firebaseUser?.name || req.firebaseUser?.email?.split("@")[0] || "User",
+  role: req.userRole || "farmer",
+  img: req.firebaseUser?.picture || null,
+});
+
+/**
+ * POST /api/auth/sync-user
+ * Firebase Auth is the identity provider. Firestore stores the application
+ * profile and role; passwords and server-issued JWTs are never persisted.
+ */
+export const syncGoogleUser = async (req, res) => {
+  try {
+    if (!req.firebaseUser?.uid) return res.status(401).json({ message: "Unauthorized" });
+
+    const uid = req.firebaseUser.uid;
+    const existing = await User.findById(uid);
+    const requestedRole = req.body?.role;
+    const role = existing?.role || requestedRole || req.userRole || "farmer";
+    const profile = {
+      ...profileFromRequest(req),
+      role,
+      email: normalizeEmail(req.firebaseUser.email),
+      updatedAt: new Date(),
+    };
+
+    const user = await User.findByIdAndUpdate(uid, { $set: profile }, { upsert: true, new: true });
+    return res.status(200).json({
+      message: "User synced",
+      role: user?.role || role,
+      userId: uid,
+      user,
+    });
+  } catch (error) {
+    console.error("syncFirebaseUser error:", error);
+    return res.status(500).json({ message: "Unable to sync Firebase user" });
+  }
+};
+
+// Password creation and verification now happen in Firebase Auth on the client.
+// These routes remain explicit so stale clients receive a clear migration error
+// rather than silently creating a legacy JWT session.
+export const signup = async (_req, res) => res.status(410).json({
+  message: "Password signup moved to Firebase Authentication. Please update the app.",
+});
+
+export const signin = async (_req, res) => res.status(410).json({
+  message: "Password sign-in moved to Firebase Authentication. Please update the app.",
+});
+
+export const signout = async (req, res) => {
+  res.clearCookie("firebaseToken", { httpOnly: true, secure: true, sameSite: "none", path: "/" });
+  return res.status(200).json({ message: "Logged out successfully" });
+};
+
+export const getUserProfile = async (req, res) => {
+  try {
+    if (!req.userId) return res.status(401).json({ message: "Authentication required" });
+    const user = await User.findById(req.userId);
+    return res.json(user || profileFromRequest(req));
+  } catch (error) {
+    console.error("getUserProfile error:", error);
+    return res.status(500).json({ message: "Internal server error" });
+  }
+};

backend/controllers/blogRecommendationsController.js

@@ -0,0 +1,29 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from 'dotenv';
+
+export const getBlogRecommendations = async (req, res) => {
+    dotenv.config();
+
+    const { region: _region } = req.query;
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\nRespond STRICTLY in ${langName} language.` : '';
+
+    try {
+        const promptText = `
+            please provide the following for the experts with new recommendations every time :
+            
+             Suggest 2 topics in 5-6 words that an expert can write about to help farmers address current issues effectively .
+            
+
+            Keep each point clear, expert-friendly, and should focus on the most current weather problems, crop health problems, or economic conditions of the farmers or any recent concerns.${langInstruction}
+        `;
+
+        const recommendations = await generateAIContent(promptText.trim());
+        res.status(200).json({ recommendations });
+    } catch (err) {
+        console.error("Error fetching expert recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};

backend/controllers/cropController.js

@@ -0,0 +1,47 @@
+import Crop from '../models/crop.model.js';
+
+export const addCrop = async (req, res) => {
+  try {
+    console.log("User ID:", req.userId);  // Log the user ID for debugging
+    const newCrop = new Crop({
+      ...req.body,
+      user: req.userId,  // Make sure req.userId is set by the middleware
+    });
+    
+    const savedCrop = await newCrop.save();
+    res.status(201).json(savedCrop);
+  } catch (error) {
+    res.status(500).json({ message: "Error occurred while adding crop", error });
+  }
+};
+
+export const getAllCrops = async (req, res) => {
+  try {
+    const crops = await Crop.find({ user: req.userId }).populate("irrigationData");
+    res.status(200).json(crops);
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
+};
+
+export const updateCrop = async (req, res) => {
+  const { id } = req.params;
+  const { name, growthProgress, yieldData } = req.body;
+  try {
+    const crop = await Crop.findOne({ _id: id, user: req.userId });
+    if (!crop) return res.status(404).json({ message: "Crop not found" });
+    
+    if (name) crop.name = name;
+    if (growthProgress !== undefined) crop.growthProgress = growthProgress;
+
+    // Ensure yieldData is an array of objects with "month" and "yield"
+    if (Array.isArray(yieldData) && yieldData.every(item => item.month && item.yield)) {
+      crop.yieldData.push(...yieldData);
+    }
+
+    const updatedCrop = await crop.save();
+    res.status(200).json(updatedCrop);
+  } catch (err) {
+    res.status(500).json({ message: "Failed to update crop", error: err.message });
+  }
+};

backend/controllers/cropRotationController.js

@@ -0,0 +1,66 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from "dotenv";
+
+export const cropRotationRecommendations = async (req, res) => {
+    dotenv.config();
+
+    const { previousCrop, npkDepletion, waterAvailability, soilType, region } =
+        req.body;
+
+    if (
+        !previousCrop ||
+        !npkDepletion ||
+        !waterAvailability ||
+        !soilType ||
+        !region
+    ) {
+        return res.status(400).json({
+            error: "Missing required inputs: previousCrop, npkDepletion, waterAvailability, soilType, region",
+        });
+    }
+
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\n\nRespond STRICTLY in ${langName} language. Translate all fields and values.` : '';
+
+    try {
+        const prompt = `
+        You are an expert agricultural crop rotation scientist.
+
+        Based on the following:
+        - Previous Crop: ${previousCrop}
+        - NPK Depletion (major nutrient lost): ${npkDepletion}
+        - Water Availability: ${waterAvailability}
+        - Soil Type: ${soilType}
+        - Region: ${region}
+
+        Suggest the best crop to plant next to:
+        - Restore depleted nutrients naturally
+        - Increase soil fertility long-term
+        - Improve economic profitability
+
+        Provide the answer ONLY in this strict JSON format:
+
+        {
+            "recommended_crop": "",
+            "reasons": ["", "", ""],
+            "nutrient_restoration_benefit": "",
+            "expected_profitability": "",
+            "note": ""
+        }${langInstruction}
+        `;
+
+        const recommendation = await generateAIContent(prompt.trim());
+        const formattedRecommendation = recommendation
+            .replace("```json", "")
+            .replace("```", "")
+            .trim();
+        res.status(200).json({
+            recommendation: formattedRecommendation,
+        });
+    } catch (err) {
+        console.error("Error fetching recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};

backend/controllers/detectHarvestReadinessController.js

@@ -0,0 +1,92 @@
+import dotenv from "dotenv";
+import { generateAIContentWithVision } from "../utils/aiHelper.js";
+import { extractLanguage, getLanguageName } from "../utils/aiOrchestrator.js";
+import FormData from "form-data";
+
+const AI_BACKEND_URL = process.env.AI_BACKEND_URL || "http://localhost:5000";
+
+/**
+ * Try the YOLO harvest readiness model on the AI backend first.
+ * Returns the result object or null if the AI backend is unavailable.
+ */
+async function tryYoloModel(fileBuffer, originalname, mimetype) {
+    try {
+        const form = new FormData();
+        form.append("file", fileBuffer, {
+            filename: originalname || "image.jpg",
+            contentType: mimetype || "image/jpeg",
+        });
+
+        const response = await fetch(`${AI_BACKEND_URL}/harvest_readiness`, {
+            method: "POST",
+            body: form,
+            headers: form.getHeaders(),
+        });
+
+        if (!response.ok) return null;
+        const data = await response.json();
+        if (data.error) return null;
+        return data;
+    } catch {
+        return null;
+    }
+}
+
+export const detectHarvestReadiness = async (req, res) => {
+    dotenv.config();
+    try {
+        if (!req.file) {
+            return res.status(400).json({ error: "No image uploaded" });
+        }
+
+        // Try YOLO model first
+        const yoloResult = await tryYoloModel(
+            req.file.buffer,
+            req.file.originalname,
+            req.file.mimetype
+        );
+        if (yoloResult) {
+            return res.status(200).json(yoloResult);
+        }
+
+        // Fallback to Gemini vision AI
+        const base64Image = req.file.buffer?.toString("base64");
+        const lang = extractLanguage(req);
+        const langName = getLanguageName(lang);
+        const langInstruction = lang !== 'en' ? `\nRespond STRICTLY in ${langName} language for the "note" field.` : '';
+
+        const prompt = `
+        You are an agricultural expert.
+
+        Analyze the crop in this image and provide:
+
+        1. Whether the crop is ready for harvest (Yes/No).
+        2. Percentage maturity (0–100%).
+        3. Estimated days left for optimal harvest.
+        4. Very short explanation (1–2 lines).
+
+        Return data in strict JSON format:
+        {
+            "ready": "Yes/No",
+            "maturity": 0-100,
+            "days_left": number,
+            "note": "short text"
+        }${langInstruction}
+        `;
+
+        const aiText = await generateAIContentWithVision(prompt, base64Image, req.file.mimetype);
+        
+        const cleanJsonString = aiText.replace("```json", "").replace("```", "").trim();
+        
+        try {
+            const result = JSON.parse(cleanJsonString);
+            return res.status(200).json(result);
+        } catch (_err) {
+            console.log("AI did not return valid JSON:", aiText);
+            return res.status(500).json({ error: "Failed to parse AI response", raw: aiText });
+        }
+    } catch (error) {
+        console.error("Error detecting harvest readiness:", error.message || error);
+        res.status(500).json({ error: "Failed to detect harvest readiness" });
+    }
+};

backend/controllers/expertDetailsController.js

@@ -0,0 +1,128 @@
+import ExpertDetails from '../models/expertDetail.model.js';
+import User from '../models/auth.model.js';
+
+// Get Expert Details
+export const getExpertDetails = async (req, res) => {
+  try {
+    const expertDetails = await ExpertDetails.findOne({ userId: req.params.userId });
+    
+    // If expert details are not found, return default values
+    if (!expertDetails) {
+      const defaultDetails = {
+        expertStats: { successfulAppointments: 0, farmersHelped: 0, experience: 0, rating: 0 },
+        appointmentStats: { 
+          totalAppointments: 0, 
+          satisfactionRating: 0, 
+          adviceAreas: { cropManagement: 0, pestControl: 0, irrigation: 0 } 
+        },
+        blogEngagement: { views: 0, comments: 0, likes: 0 }
+      };
+      return res.status(200).json(defaultDetails);
+    }
+
+    res.status(200).json(expertDetails);
+  } catch (error) {
+    res.status(500).json({ message: 'Server Error', error });
+  }
+};
+
+// Add Expert Details
+export const addExpertDetails = async (req, res) => {
+  try {
+    const userId = req.userId; // Use authenticated user's ID
+    const { expertStats, appointmentStats, blogEngagement } = req.body;
+
+    // Check if the user exists and is an expert
+    const user = await User.findById(userId);
+    if (!user || user.role !== 'expert') {
+      return res.status(400).json({ message: 'Invalid expert user ID' });
+    }
+
+    // Check if expert details already exist
+    const existingDetails = await ExpertDetails.findOne({ userId });
+    if (existingDetails) {
+      return res.status(400).json({ message: 'Expert details already exist' });
+    }
+
+    const newExpertDetails = new ExpertDetails({
+      userId,
+      expertStats,
+      appointmentStats,
+      blogEngagement,
+    });
+
+    await newExpertDetails.save();
+    res.status(201).json(newExpertDetails);
+  } catch (error) {
+    res.status(500).json({ message: 'Server Error', error });
+  }
+};
+
+// Update Expert Details
+export const updateExpertDetails = async (req, res) => {
+  try {
+    // Try to find the expert details for the given userId
+    let expertDetails = await ExpertDetails.findOne({ userId: req.params.userId });
+
+    // If expert details don't exist, create a new document for this user
+    if (!expertDetails) {
+      expertDetails = new ExpertDetails({
+        userId: req.params.userId,
+        expertStats: {
+          successfulAppointments: 0,
+          farmersHelped: 0,
+          experience: 0,
+          rating: 0
+        },
+        appointmentStats: {
+          totalAppointments: 0,
+          satisfactionRating: 0,
+          adviceAreas: {
+            cropManagement: 0,
+            pestControl: 0,
+            irrigation: 0
+          }
+        },
+        blogEngagement: {
+          views: 0,
+          comments: 0,
+          likes: 0
+        }
+      });
+    }
+
+    // Update the expert details with the values from the request body, if provided
+    const { expertStats, appointmentStats, blogEngagement } = req.body;
+
+    if (expertStats) {
+      expertDetails.expertStats = {
+        ...expertDetails.expertStats.toObject(),
+        ...expertStats
+      };
+    }
+    
+    if (appointmentStats) {
+      expertDetails.appointmentStats = {
+        ...expertDetails.appointmentStats.toObject(),
+        ...appointmentStats
+      };
+    }
+    
+    if (blogEngagement) {
+      expertDetails.blogEngagement = {
+        ...expertDetails.blogEngagement.toObject(),
+        ...blogEngagement
+      };
+    }
+
+    // Save the updated expert details
+    await expertDetails.save();
+
+    // Respond with the updated expert details
+    res.status(200).json(expertDetails);
+
+  } catch (error) {
+    // Handle any server errors
+    res.status(500).json({ message: 'Server Error', error });
+  }
+};

backend/controllers/farmerDetailsController.js

@@ -0,0 +1,92 @@
+import FarmerDetails from "../models/farmerDetail.model.js";
+import User from '../models/auth.model.js'
+
+//getting farmer details by id
+export const getFarmerDetails = async (req, res) => {
+    try {
+      const farmerDetails = await FarmerDetails.findOne({ user: req.params.userId });
+      if (!farmerDetails) {
+        return res.status(404).json({ message: 'Farmer details not found' });
+      }
+      res.status(200).json(farmerDetails);
+    } catch (error) {
+      res.status(500).json({ message: 'Server Error', error });
+    }
+  };
+
+//adding farmer details
+export const addFarmerDetails = async(req,res)=>{
+    try{
+        const userId = req.userId
+        const {phone, address, region, climate, cropNames, amountOfLand, otherDetails}= req.body
+
+        const user = await User.findById(userId)
+        if(!user || user.role!=='farmer'){
+            return res.status(400).json({message:"Invalid expert user ID"})
+        }
+
+        const existingDetails = await FarmerDetails.findOne({userId})
+        if(existingDetails){
+            return res.status(400).json({message:'Farmer details already exist'})
+        }
+
+        const newFarmerDetails = new FarmerDetails({
+            user: userId,
+            phone,
+            address,
+            region,
+            climate,
+            cropNames,
+            amountOfLand,
+            otherDetails
+        })
+        await newFarmerDetails.save()
+        res.status(201).json(newFarmerDetails)
+
+    }catch(error){
+    res.status(500).json({ message: 'Server Error', error });
+    }
+} 
+
+export const updateFarmerDetails = async (req, res) => {
+    try {
+        // Find the farmer's details based on the userId in the URL
+        const farmerDetails = await FarmerDetails.findOne({ user: req.params.userId });
+        if (!farmerDetails) {
+            return res.status(404).json({ message: "Farmer details not found" });
+        }
+
+        // Destructure fields from the request body
+        const { phone, address, region, climate, cropNames, amountOfLand, otherDetails } = req.body;
+
+        // Update fields only if they are provided and different from the existing values
+        if (phone && phone !== farmerDetails.phone) {
+            farmerDetails.phone = phone;
+        }
+        if (address && address !== farmerDetails.address) {
+            farmerDetails.address = address;
+        }
+        if (region && region !== farmerDetails.region) {
+            farmerDetails.region = region;
+        }
+        if (climate && climate !== farmerDetails.climate) {
+            farmerDetails.climate = climate;
+        }
+        if (cropNames && JSON.stringify(cropNames) !== JSON.stringify(farmerDetails.cropNames)) {
+            farmerDetails.cropNames = cropNames;
+        }
+        if (amountOfLand && amountOfLand !== farmerDetails.amountOfLand) {
+            farmerDetails.amountOfLand = amountOfLand;
+        }
+        if (otherDetails && otherDetails !== farmerDetails.otherDetails) {
+            farmerDetails.otherDetails = otherDetails;
+        }
+
+        // Save the updated farmer details
+        await farmerDetails.save();
+
+        res.status(200).json({ message: "Farmer details updated successfully", farmerDetails });
+    } catch (error) {
+        res.status(500).json({ message: "Error updating farmer details", error });
+    }
+};

backend/controllers/farmingNewsController.js

@@ -0,0 +1,17 @@
+import axios from 'axios'
+
+export const getFarmingNews = async(req, res)=>{
+    const api_key = process.env.NEWS_API_KEY;
+    const url = `https://newsapi.org/v2/everything?q=farming&apiKey=${api_key}`;
+
+    try{
+        const response = await axios.get(url);
+        // console.log(response);
+        const articles = response.data.articles;
+        // console.log(" Articles is  : ", articles);
+        res.status(200).json(articles);
+    }catch(err){
+        console.error("Error fetching news : ", err);
+        res.status(500).json({message : "Error fetching news"});
+    }
+}

backend/controllers/geoPestDiseaseHeatmapController.js

@@ -0,0 +1,60 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from "dotenv";
+
+export const geoPestDiseaseHeatmapRecommendations = async (req, res) => {
+    dotenv.config();
+
+    const { location, cropType, cropStage } = req.body;
+
+    if (!location) {
+        return res.status(400).json({
+            error: "Missing required input: location",
+        });
+    }
+
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\n\nRespond STRICTLY in ${langName} language. Translate all fields and values.` : '';
+
+    try {
+        const prompt = `
+        You are an agricultural pest & disease outbreak prediction expert.
+
+        Analyze early pest/disease outbreak risks based on:
+        - Farm Location: ${location}
+        - Crop Type (optional): ${cropType || "Not provided"}
+        - Crop Stage (optional): ${cropStage || "Not provided"}
+
+        Use indicators such as:
+        - Satellite vegetation stress signals
+        - Humidity + temperature patterns
+        - Rainfall + soil moisture
+        - Community farmer reports in nearby villages
+        - Seasonal pest migration trends
+
+        Provide ONLY the JSON output in the following format:
+
+        {
+            "risk_level": "Low/Moderate/High/Severe",
+            "hotspot_zones": ["", "", ""],
+            "likely_threat": "",
+            "expected_outbreak_days": 0,
+            "preventive_actions": ["", "", ""],
+            "note": ""
+        }${langInstruction}
+        `;
+
+        const recommendation = await generateAIContent(prompt.trim());
+        const formattedRecommendation = recommendation
+            .replace("```json", "")
+            .replace("```", "")
+            .trim();
+        res.status(200).json({
+            recommendation: formattedRecommendation,
+        });
+    } catch (err) {
+        console.error("Error fetching recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};

backend/controllers/getExpertsController.js

@@ -0,0 +1,11 @@
+import User from '../models/auth.model.js'
+
+// controller to get all expert user
+export const getExperts = async(req, res)=>{
+    try{
+        const experts = await User.find({role: 'expert'});
+        res.status(200).json(experts);
+    }catch(err){
+        res.status(500).json({message : "Failed to fetch the user details", err});
+    }
+}

backend/controllers/getLoanEligibilityReportController.js

@@ -0,0 +1,73 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from "dotenv";
+
+export const getLoanEligibilityReport = async (req, res) => {
+    dotenv.config();
+
+    const {
+        location,
+        landSize,
+        landType,
+        cropType,
+        cropStage,
+        pastYield,
+        existingLoans,
+    } = req.body;
+
+    if (!location || !landSize || !landType || !cropType || !cropStage) {
+        return res.status(400).json({
+            error: "Missing required inputs: location, landSize, landType, cropType, cropStage",
+        });
+    }
+
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\n\nRespond STRICTLY in ${langName} language. Translate all fields and values.` : '';
+
+    try {
+        const prompt = `
+        You are an expert agricultural financial analyst who evaluates farmer credit eligibility based on farm potential and financial risk.
+
+        Evaluate the farmer using:
+        - Farm Location: ${location}
+        - Land Size: ${landSize}
+        - Land Type: ${landType}
+        - Crop Type: ${cropType}
+        - Crop Stage: ${cropStage}
+        - Past Yield (optional): ${pastYield || "Not provided"}
+        - Existing Loans (optional): ${existingLoans || "Not provided"}
+
+        Consider:
+        - Crop yield prediction
+        - Soil health and farm productivity potential
+        - Market price forecast & demand trends
+        - Climate risk profile (drought/flood probability)
+        - Irrigation access and fertilizer usage (assume based on crop & region if not given)
+        - Cropping pattern stability
+
+        Provide the output ONLY in the following JSON format:
+
+        {
+            "loan_approval_probability": 0,
+            "eligible_loan_amount_range": "",
+            "risk_category": "",
+            "expected_repayment_capacity": "",
+            "recommendations": ["", "", ""],
+            "note": ""
+        }${langInstruction}
+        `;
+
+        const recommendation = await generateAIContent(prompt.trim());
+        const formattedRecommendation = recommendation
+            .replace("```json", "")
+            .replace("```", "")
+            .trim();
+        res.status(200).json({
+            recommendation: formattedRecommendation,
+        });
+    } catch (err) {
+        console.error("Error fetching recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};

backend/controllers/irrigationController.js

@@ -0,0 +1,37 @@
+// controllers/irrigationController.js
+import Irrigation from '../models/irrigation.model.js';
+
+export const addIrrigationData = async (req, res) => {
+  const { cropId } = req.params;
+  const { month, waterUsage, forecastedUsage } = req.body;
+
+  try {
+
+    const userId = req.userId;
+    // Create and save new irrigation data associated with the crop
+    const irrigationData = new Irrigation({
+      crop: cropId,
+      user: userId,
+      month,
+      waterUsage,
+      forecastedUsage,
+    });
+    await irrigationData.save();
+
+    res.status(201).json({ message: 'Irrigation data added successfully', irrigationData });
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to add irrigation data', error });
+  }
+};
+
+// Optional: Controller to get all irrigation data for a specific crop
+export const getAllIrrigationDataByCrop = async (req, res) => {
+  const { cropId } = req.params;
+  try {
+    const userId = req.userId;
+    const irrigationData = await Irrigation.find({ crop: cropId, user: userId });
+    res.status(200).json(irrigationData);
+  } catch (error) {
+    res.status(500).json({ message: 'Failed to retrieve irrigation data', error });
+  }
+};

backend/controllers/marketPredictionController.js

@@ -0,0 +1,76 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from "dotenv";
+
+export const marketPredictionRecommendations = async (req, res) => {
+    dotenv.config();
+
+    const {
+        cropType,
+        region,
+        currentPrice,
+        mandiOptions,
+        season,
+        marketArrivals,
+    } = req.body;
+
+    if (
+        !cropType ||
+        !region ||
+        !currentPrice ||
+        !mandiOptions ||
+        !season ||
+        !marketArrivals
+    ) {
+        return res.status(400).json({
+            error: "Missing required inputs: cropType, region, currentPrice, mandiOptions, season, marketArrivals",
+        });
+    }
+
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\n\nRespond STRICTLY in ${langName} language. Translate all fields and values.` : '';
+
+    try {
+        const prompt = `
+        You are an agricultural market economist specializing in crop price forecasting.
+
+        Analyze and predict crop selling strategy based on:
+        - Crop: ${cropType}
+        - Region: ${region}
+        - Current Price: ${currentPrice}
+        - Available Mandis/Markets: ${mandiOptions}
+        - Current Season/Festival Impact: ${season}
+        - Market Arrivals (supply level): ${marketArrivals}
+
+        Consider:
+        - Historical mandi data
+        - Demand–supply trends
+        - Seasonal/Festival inflation
+        - Weather influence on supply
+
+        Provide ONLY this JSON output:
+
+        {
+            "predicted_price_next_week": "₹value per quintal/kg",
+            "sell_now": "Yes/No",
+            "best_market": "",
+            "price_trend": "Rising/Stable/Falling",
+            "expected_change_percent": 0,
+            "note": ""
+        }${langInstruction}
+        `;
+
+        const recommendation = await generateAIContent(prompt.trim());
+        const formattedRecommendation = recommendation
+            .replace("```json", "")
+            .replace("```", "")
+            .trim();
+        res.status(200).json({
+            recommendation: formattedRecommendation,
+        });
+    } catch (err) {
+        console.error("Error fetching recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};

backend/controllers/notificationsController.js

@@ -0,0 +1,88 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from 'dotenv';
+import { Notification } from "../utils/firestoreCollections.js";
+
+export const getFarmingAlerts = async (req, res) => {
+    dotenv.config();
+    
+    const { region } = req.query;
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\nRespond STRICTLY in ${langName} language.` : '';
+
+    try {
+        const promptText = `
+            Please provide a maximum of 2 short and recent farming alerts or notifications in max 5-6 words related to farming weather and conditions, specifically for the region of ${region}.
+
+            Focus on:
+            - Important weather-related alerts relevant to farming today.
+            - Any immediate farming precautions or actions farmers should take.
+
+            Keep each alert clear, brief, and farmer-friendly. Thank you!${langInstruction}
+        `;
+
+        const alerts = await generateAIContent(promptText.trim());
+        res.status(200).json({ alerts });
+    } catch (err) {
+        console.error("Error fetching farming alerts: ", err);
+        res.status(500).json({ error: "Failed to fetch alerts" });
+    }
+};
+
+export const listNotifications = async (req, res) => {
+    try {
+        const userId = req.user?._id;
+
+        if (!userId) {
+            return res.status(401).json({ success: false, error: 'Unauthorized' });
+        }
+
+        const notifications = await Notification.find({ userId }).sort('-createdAt').limit(20).lean();
+        const unread = notifications.filter((n) => !n.read).length;
+
+        return res.status(200).json({
+            success: true,
+            data: {
+                notifications,
+                unread,
+            },
+        });
+    } catch (err) {
+        return res.status(500).json({ success: false, error: err.message });
+    }
+};
+
+export const seedNotification = async (req, res) => {
+    try {
+        const userId = req.user?._id;
+        if (!userId) {
+            return res.status(401).json({ success: false, error: 'Unauthorized' });
+        }
+
+        const { title, message, type = 'general', link } = req.body || {};
+        if (!title || !message) {
+            return res.status(400).json({ success: false, error: 'title and message are required' });
+        }
+
+        const created = await Notification.create({ userId, title, message, type, link });
+        return res.status(201).json({ success: true, data: created });
+    } catch (err) {
+        return res.status(500).json({ success: false, error: err.message });
+    }
+};
+
+export const markNotificationRead = async (req, res) => {
+    try {
+        const userId = req.user?._id;
+        const { id } = req.params;
+        if (!userId) {
+            return res.status(401).json({ success: false, error: 'Unauthorized' });
+        }
+
+        await Notification.updateOne({ _id: id, userId }, { $set: { read: true } });
+        return res.status(200).json({ success: true });
+    } catch (err) {
+        return res.status(500).json({ success: false, error: err.message });
+    }
+};

backend/controllers/pestOutbreakController.js

@@ -0,0 +1,62 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from "dotenv";
+
+export const pestOutbreakRecommendations = async (req, res) => {
+    dotenv.config();
+
+    const { region, weather, cropType, communityReports } = req.body;
+
+    if (!region || !weather || !cropType || !communityReports) {
+        return res.status(400).json({
+            error: "Missing required inputs: region, weather, cropType, communityReports",
+        });
+    }
+
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\n\nRespond STRICTLY in ${langName} language. Translate all fields and values.` : '';
+
+    try {
+        const prompt = `
+        You are an agricultural pest outbreak prediction expert.
+
+        Analyze the risk of pest infestation using:
+        - Region: ${region}
+        - Weather forecast: ${weather}
+        - Crop type: ${cropType}
+        - Community pest reports (last 7 days): ${communityReports}
+
+        Provide:
+        1. Whether there is a risk of pest outbreak (Yes/No)
+        2. Likely pest that may attack (e.g., stem borer, aphids, bollworm, etc.)
+        3. Risk level (%) based on severity and probability
+        4. Expected time window (days until possible outbreak)
+        5. Preventive actions farmers should take immediately (bullet points)
+        6. A short note (1–2 lines of advice)
+
+        Respond ONLY in this JSON format:
+
+        {
+            "outbreak_risk": "",
+            "likely_pest": "",
+            "risk_level_percent": 0,
+            "expected_days": 0,
+            "preventive_actions": ["", "", ""],
+            "note": ""
+        }${langInstruction}
+        `;
+
+        const recommendation = await generateAIContent(prompt.trim());
+        const formattedRecommendation = recommendation
+            .replace("```json", "")
+            .replace("```", "")
+            .trim();
+        res.status(200).json({
+            recommendation: formattedRecommendation,
+        });
+    } catch (err) {
+        console.error("Error fetching recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};

backend/controllers/postController.js

@@ -0,0 +1,95 @@
+import Post from '../models/post.model.js';
+
+// creating a post
+export const createPost = async(req, res)=>{
+    try{
+        const {title, content} = req.body;
+        const post = new Post({title, content, author: req.userId});
+        await post.save();
+        res.status(201).json({message: "Post saved successfully", post});
+    }catch(err){
+        res.status(500).json({message: "Something went wrong", err});
+    }
+}
+
+// Get all posts for loggedin user
+export const getAllPost = async(req, res)=>{
+    try{
+        const posts = await Post.find().populate('author', 'username');
+        res.status(200).json(posts);
+    }catch(err){
+        res.status(500).json({message: "Error fetching all post", err});
+    }
+}
+
+// Get posts of a user
+export const getPostsByUser = async (req, res) => {
+    try {
+      // Extract userId from the authenticated user (JWT token)
+      const userId = req.userId;  // Assuming the userId is decoded and set in the token verification middleware
+  
+      if (!userId) {
+        return res.status(400).json({ message: 'User ID is missing or invalid' });
+      }
+  
+      // Find posts based on the userId
+      const posts = await Post.find({ author: userId }).populate('author', 'username');
+      if (posts.length === 0) {
+        return res.status(404).json({ message: 'No posts found for this user' });
+      }
+      res.status(200).json(posts);
+    } catch (err) {
+      console.error('Error fetching user posts:', err);
+      res.status(500).json({ message: 'Error fetching user posts', error: err.message });
+    }
+  };
+
+export const getPostById = async(req, res)=>{
+    try{
+        const {id} = req.params;
+        const post = await Post.findById(id).populate('author', 'username');
+        if(!post){
+            return res.status(404).json({message: 'Post not found'});
+        }
+
+        res.status(200).json(post);
+    }catch(err){
+        res.status(500).json({message: 'Error fetching the post', error: err.message})
+    }
+}
+
+
+
+// update post
+export const updatePost = async(req, res)=>{
+    try{
+        const {id} = req.params;
+        const {title, content} = req.body;
+        const post = await Post.findByIdAndUpdate({
+            _id: id, author: req.userId
+        },
+        {
+            title, content
+        },{
+            new: true
+        });
+        if(!post){
+            return res.status(404).json({message: "Post not found or you are not authorized"});
+        }
+        res.status(200).json({message: "Post updated successfully", post});
+    }catch(err){
+        res.status(500).json({message: "Failed to update post", err});
+    }
+}
+
+// Delete post
+export const deletePost = async(req, res)=>{
+    try{
+        const {id} = req.params;
+        const post = await Post.findByIdAndDelete({_id: id, author: req.userId});
+        if(!post) res.status(404).json({message: "Post not found or you are not authorized"});
+        res.status(200).json({message: 'Post deleted successfully'});
+    }catch(err){
+        res.status(500).json({message: "Failed to delete post", err});
+    }
+}

backend/controllers/recommendationController.js

@@ -0,0 +1,38 @@
+import dotenv from 'dotenv';
+import { extractLanguage } from '../utils/aiOrchestrator.js';
+import { generateAIContent } from '../utils/aiHelper.js';
+
+export const getRecommendations = async (req, res) => {
+    dotenv.config();
+    
+    const { climate, soilType, cropType, cropInfo, weatherDetails, cropConditions } = req.body;
+    const lang = extractLanguage(req);
+
+    try {
+        // Construct a detailed prompt for the API based on the farmer's inputs
+        const promptText = `
+            Please provide farming recommendations based on the following information:
+
+            1. **Climate**: ${climate}
+            2. **Soil Type**: ${soilType}
+            3. **Crop Type**: ${cropType}
+            4. **Information about the Crop**: ${cropInfo}
+            5. **Today's Weather**: ${weatherDetails}
+            6. **Crop Conditions**: ${cropConditions}
+
+            Based on this information, please suggest:
+            - Suitable farming practices for today.
+            - Care tips for the specified crop considering the current weather and soil conditions.
+            - Any precautions to take given today's weather and crop requirements.
+
+            Make the recommendations clear and easy to understand for farmers. Thank you!
+            ${lang !== 'en' ? `\n\nRespond STRICTLY in ${req.langName || 'the user\'s preferred language'}.` : ''}
+        `;
+
+        const recommendation = await generateAIContent(promptText.trim());
+        res.status(200).json({ recommendation });
+    } catch (err) {
+        console.error("Error fetching recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};

backend/controllers/recordController.js

@@ -0,0 +1,76 @@
+import Record from "../models/record.model.js";
+import MonthlySummary from'../models/monthlySummary.model.js'
+
+export const addRecord = async(req,res)=>{
+  try {
+    console.log(req.body);
+    const { date, expenditure, earnings } = req.body;
+    const parsedDate = new Date(date);
+    const month = parsedDate.getMonth() + 1; // JS months are 0-indexed, so add 1
+    const year = parsedDate.getFullYear();
+    const userId = req.userId;
+
+    const record = new Record({
+      date: parsedDate,
+      expenditure,
+      earnings,
+      month,
+      year,
+      user: userId,
+    });
+
+    await record.save();
+    res.status(201).json({ message: 'Record added successfully' });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to add record', details: error.message });
+  }
+}
+
+export const getMonthlySummary = async (req, res) => {
+  try {
+    const { year } = req.params;
+    const userId = req.userId;
+    const summaries = await MonthlySummary.find({ year, user: userId });
+
+    res.status(200).json(summaries);
+  } catch (_error) {
+    res.status(500).json({ error: 'Failed to retrieve monthly summaries' });
+  }
+};
+
+export const calculateMonthlySummary = async(req,res)=>{
+  try {
+      const { month, year } = req.body;
+      const userId = req.userId;
+  
+      const records = await Record.find({ month, year, user: userId });
+  
+      const totalEarnings = records.reduce((sum, record) => sum + record.earnings, 0);
+      const totalExpenditure = records.reduce((sum, record) => sum + record.expenditure, 0);
+      const revenue = totalEarnings - totalExpenditure;
+  
+      // Check if a summary already exists for this month and year
+      let monthlySummary = await MonthlySummary.findOne({ month, year, user: userId });
+      if (monthlySummary) {
+        // Update existing summary
+        monthlySummary.totalEarnings = totalEarnings;
+        monthlySummary.totalExpenditure = totalExpenditure;
+        monthlySummary.revenue = revenue;
+      } else {
+        // Create a new summary
+        monthlySummary = new MonthlySummary({
+          month,
+          year,
+          totalEarnings,
+          totalExpenditure,
+          revenue,
+          user: userId,
+        });
+      }
+  
+      await monthlySummary.save();
+      res.status(200).json({ message: 'Monthly summary calculated and saved successfully', monthlySummary });
+    } catch (_error) {
+      res.status(500).json({ error: 'Failed to calculate monthly summary' });
+    }
+}

backend/controllers/soilHealthController.js

@@ -0,0 +1,74 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from "dotenv";
+
+export const soilHealthRecommendations = async (req, res) => {
+    dotenv.config();
+
+    const {
+        soilPH,
+        organicMatter,
+        nitrogen,
+        phosphorus,
+        potassium,
+        salinity,
+        cropType,
+    } = req.body;
+
+    if (
+        soilPH === undefined ||
+        organicMatter === undefined ||
+        nitrogen === undefined ||
+        phosphorus === undefined ||
+        potassium === undefined ||
+        salinity === undefined ||
+        !cropType
+    ) {
+        return res.status(400).json({
+            error: "Missing required inputs: soilPH, organicMatter, nitrogen, phosphorus, potassium, salinity, cropType",
+        });
+    }
+
+    const lang = extractLanguage(req);
+    const langName = getLanguageName(lang);
+    const langInstruction = lang !== 'en' ? `\n\nRespond STRICTLY in ${langName} language. Translate all fields and values.` : '';
+
+    try {
+        const prompt = `
+        You are an expert soil scientist.
+
+        Based on the soil data below:
+        - pH: ${soilPH}
+        - Organic Matter (%): ${organicMatter}
+        - Nitrogen (N): ${nitrogen}
+        - Phosphorus (P): ${phosphorus}
+        - Potassium (K): ${potassium}
+        - Salinity (EC): ${salinity}
+        - Crop Type: ${cropType}
+
+        Provide:
+        1. The main current soil issue (1 short line)
+        2. Recommended amendments (bullet list; include lime, gypsum, compost, manure, biofertilizer, etc. if relevant)
+        3. NPK balancing recommendation (for example: "increase nitrogen slightly", "reduce phosphorus", etc.)
+        4. Estimated time for improvement (e.g., "2–4 weeks", "1–2 months")
+        5. A short explanation
+
+        ⚠️ Respond ONLY in valid JSON with this structure:
+
+        {
+            "current_issue": "",
+            "recommended_amendments": ["", "", ""],
+            "npk_adjustment": "",
+            "expected_improvement_time": "",
+            "note": ""
+        }${langInstruction}
+        `;
+
+        const recommendation = await generateAIContent(prompt.trim());
+        const formattedRecommendation = recommendation.replace("```json", "").replace("```", "").trim();
+        res.status(200).json({ recommendation: formattedRecommendation });
+    } catch (err) {
+        console.error("Error fetching recommendations: ", err);
+        res.status(500).json({ error: "Failed to fetch recommendations" });
+    }
+};