auto: sync backend from github@32fb9685

.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:20-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,331 @@
+---
+title: Agromind Backend
+emoji: 🚀
+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/push_to_hf.yml`.
+
+
+### 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,1570 @@
+"""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/agromind-plant-disease-nfnet
+#   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/agromind-plant-disease-nfnet 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")
+        top_label, confidence, topk = predict(model, pil_img, labels, device, topk=5)
+
+        # 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,201 @@
+"""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/agromind-plant-disease-nfnet"
+)
+HF_REPO_MOBILENET = os.environ.get(
+    "HF_REPO_MOBILENET", "Arko007/agromind-plant-disease-mobilenet"
+)
+
+# 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_mobilenet_model(num_classes, device, checkpoint_path):
+    model = models.mobilenet_v2(pretrained=False)
+    num_ftrs = model.classifier[1].in_features
+    model.classifier[1] = torch.nn.Linear(num_ftrs, num_classes)
+
+    state = torch.load(checkpoint_path, map_location=device)
+    if isinstance(state, dict) and ("state_dict" in state) and not any(
+        k.startswith("module.") for k in state
+    ):
+        model.load_state_dict(state["state_dict"])
+    else:
+        try:
+            model.load_state_dict(state)
+        except Exception:
+            new_state = {}
+            for k, v in state.items():
+                name = k.replace("module.", "") if k.startswith("module.") else k
+                new_state[name] = v
+            model.load_state_dict(new_state)
+
+    model.to(device)
+    model.eval()
+    return model
+
+
+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, prefer_nfnet=True):
+    """
+    Download and load the plant-disease model from Hugging Face Hub.
+
+    Tries NFNet-F1 first (if prefer_nfnet is True), then falls back to
+    MobileNetV2.
+
+    Returns: model, labels, remedies
+    """
+    global transform
+
+    # --- Try NFNet-F1 (safetensors) ---
+    if prefer_nfnet:
+        try:
+            st_path = _download(HF_REPO_NFNET, "model.safetensors")
+            cfg_path = _download(HF_REPO_NFNET, "config.json")
+            labels_path = _download(HF_REPO_NFNET, "labels.txt")
+            remedies_path = _download(HF_REPO_NFNET, "remedies.json")
+
+            with open(cfg_path, "r", encoding="utf-8") as f:
+                config = json.load(f)
+
+            labels = config.get("class_names", [])
+            if os.path.exists(labels_path):
+                file_labels = load_labels(labels_path)
+                if len(file_labels) == len(labels):
+                    labels = file_labels
+
+            remedies = load_remedies(remedies_path)
+
+            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:
+            logger.warning(
+                "Could not load NFNet-F1 from HF Hub: %s — falling back to MobileNetV2", e
+            )
+
+    # --- Fallback: MobileNetV2 (.pth) ---
+    try:
+        pth_path = _download(HF_REPO_MOBILENET, "newplant_model_final.pth")
+        labels_path = _download(HF_REPO_MOBILENET, "labels.txt")
+        remedies_path = _download(HF_REPO_MOBILENET, "remedies.json")
+    except Exception as e:
+        raise RuntimeError(
+            f"Failed to download MobileNetV2 model from HF Hub "
+            f"({HF_REPO_MOBILENET}): {e}"
+        ) from e
+
+    labels = load_labels(labels_path)
+    remedies = load_remedies(remedies_path)
+
+    transform = transforms.Compose([
+        transforms.Resize(256),
+        transforms.CenterCrop(INPUT_SIZE),
+        transforms.ToTensor(),
+        transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD),
+    ])
+
+    model = build_mobilenet_model(len(labels), device, pth_path)
+    logger.info("Loaded MobileNetV2 model from HF Hub (%s)", HF_REPO_MOBILENET)
+    return model, labels, remedies
+
+
+def predict(model, pil_image, labels, device, topk=3):
+    """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)
+        top_probs, top_idxs = probs.topk(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
+pillow
+numpy<2
+
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch
+torchvision
+torchaudio
+
+huggingface_hub
+
+# optional for NFNet-F1 safetensors model
+timm
+safetensors
+
+flask-cors
+pandas
+scikit-learn==1.5.1
+joblib
+lightgbm
+gunicorn
+
+# Retry and testing utilities
+tenacity
+pytest
+pytest-cov
+pytest-mock
+httpx
+
+# YOLO harvest readiness model
+ultralytics
+
+# HTTP client for HF Inference API fallback
+requests

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,396 @@
+"""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(prefer_nfnet: bool = True) -> Tuple[Any, list, dict]:
+    """Load the disease detection model from HF Hub.
+    
+    Args:
+        prefer_nfnet: Try NFNet-F1 first, fallback to MobileNetV2
+    
+    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, prefer_nfnet=prefer_nfnet)
+    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(prefer_nfnet=True)
+        _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/.eslintrc.json

@@ -0,0 +1,16 @@
+{
+  "env": {
+    "node": true,
+    "es2022": true,
+    "jest": true
+  },
+  "extends": ["eslint:recommended"],
+  "parserOptions": {
+    "ecmaVersion": "latest",
+    "sourceType": "module"
+  },
+  "rules": {
+    "no-unused-vars": ["error", { "argsIgnorePattern": "^_", "varsIgnorePattern": "^_", "caughtErrorsIgnorePattern": "^_" }],
+    "no-console": "off"
+  }
+}

backend/Dockerfile

@@ -0,0 +1,55 @@
+# Backend Dockerfile (HF Spaces compatible)
+
+FROM node:20-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/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,194 @@
+import User from '../models/auth.model.js';
+import bcrypt from 'bcrypt';
+import jwt from 'jsonwebtoken';
+import mongoose from 'mongoose';
+import { validateRole } from '../utils/roleValidator.js';
+
+/**
+ * POST /api/auth/sync-user
+ * Called by the frontend after a successful Firebase/Google sign-in to ensure
+ * the user exists in MongoDB. Creates a new record for first-time Google users
+ * or links an existing email-password account to the Firebase UID.
+ * Requires a valid Firebase ID token (verified by verifyToken middleware).
+ */
+export const syncGoogleUser = async (req, res) => {
+  try {
+    if (!req.firebaseUser) {
+      return res.status(401).json({ message: 'Unauthorized' });
+    }
+    const { uid, email, name, picture } = req.firebaseUser;
+    const requestedRole = req.body?.role || 'farmer';
+    const userRole = validateRole(requestedRole);
+
+    // Find existing record by Firebase UID first, then fall back to email
+    let user = await User.findOne({ firebaseUid: uid });
+    if (!user && email) {
+      user = await User.findOne({ email: email.trim().toLowerCase() });
+    }
+
+    if (!user) {
+      // First-time Google/Firebase user — create their MongoDB record
+      user = await User.create({
+        name: name || email?.split('@')[0] || 'User',
+        email: email?.trim().toLowerCase(),
+        firebaseUid: uid,
+        role: userRole,
+        // password is intentionally omitted for OAuth users
+      });
+    } else {
+      // Existing user — backfill firebaseUid if missing
+      if (!user.firebaseUid) {
+        user.firebaseUid = uid;
+        await user.save();
+      }
+    }
+
+    return res.status(200).json({
+      message: 'User synced',
+      role: user.role,
+      userId: user._id,
+    });
+  } catch (err) {
+    console.error('syncGoogleUser error:', err);
+    return res.status(500).json({ message: 'Something went wrong' });
+  }
+};
+
+export const signup = async (req, res) => {
+const { name, email, password, role } = req.body;
+try {
+    const jwtSecret = process.env.JWT_KEY || process.env.JWT_SECRET;
+    const normalizedEmail = email?.trim().toLowerCase();
+
+    // Ensure all fields are provided
+    if (!name || !normalizedEmail || !password) {
+        return res.status(400).json({ message: "All fields are required" });
+    }
+
+    if (!jwtSecret) {
+        return res.status(500).json({ message: "Server configuration error" });
+    }
+
+    // Validate role - default to 'farmer' if not provided or invalid
+    const userRole = validateRole(role);
+
+    // Check if user already exists
+    const existingUser = await User.findOne({ email: normalizedEmail });
+    if (existingUser) return res.status(400).json({ message: "User already exists" });
+
+    // Hash password
+    const hashedPassword = await bcrypt.hash(password, 12);
+
+    // Create new user
+    const newUser = await User.create({ name, email: normalizedEmail, password: hashedPassword, role: userRole });
+
+    // Generate JWT token
+    const token = jwt.sign(
+        { id: newUser._id, role: newUser.role, email: newUser.email, name: newUser.name },
+        jwtSecret,
+        { expiresIn: "10h" }
+    );
+
+    // Set token in cookie. Use secure cookies only in production (HTTPS).
+    const cookieOptions = process.env.NODE_ENV === 'production'
+        ? { secure: true, sameSite: 'None', path: '/', maxAge: 86400000 }
+        : { secure: false, sameSite: 'Lax', path: '/' };
+
+    return res
+        .cookie('token', token, cookieOptions)
+        .status(201)
+        .json({ message: "User created successfully", token, role: newUser.role, name: newUser.name, email: newUser.email });
+} catch (err) {
+    console.error(err);
+    return res.status(500).json({ message: "Something went wrong" });
+}
+};
+
+export const signin = async (req, res) => {
+const { email, password, role } = req.body;
+try {
+    const jwtSecret = process.env.JWT_KEY || process.env.JWT_SECRET;
+    const normalizedEmail = email?.trim().toLowerCase();
+
+    if (!normalizedEmail || !password) {
+        return res.status(400).json({ message: "All fields are required" });
+    }
+
+    if (!jwtSecret) {
+        return res.status(500).json({ message: "Server configuration error" });
+    }
+
+    // Validate role only when explicitly provided
+    const userRole = role ? validateRole(role) : null;
+    
+    const user = await User.findOne({ email: normalizedEmail });
+    if (!user) return res.status(401).json({ message: "Invalid credentials" });
+
+    // Google/OAuth users have no password — they must use Google sign-in
+    if (!user.password) return res.status(401).json({ message: "This account uses Google sign-in. Please sign in with Google." });
+
+    // Check if the user's role matches the requested role
+    if (userRole && userRole !== user.role) return res.status(401).json({ message: "Invalid credentials" });
+    
+    // Validate password
+    const isPasswordCorrect = await bcrypt.compare(password, user.password);
+    if (!isPasswordCorrect) return res.status(401).json({ message: "Invalid credentials" });
+
+    // Generate JWT token
+    const token = jwt.sign(
+        { id: user._id, role: user.role, email: user.email, name: user.name },
+        jwtSecret,
+        { expiresIn: "1d" }
+    );
+
+    // Set token in cookie. Use secure cookies only in production (HTTPS).
+    if (token.length > 0) {
+        const cookieOptions = process.env.NODE_ENV === 'production'
+            ? { secure: true, sameSite: 'None', path: '/', maxAge: 86400000 }
+            : { secure: false, sameSite: 'Lax', path: '/' };
+
+        return res
+            .cookie('token', token, cookieOptions)
+            .status(200)
+            .json({ message: "Logged in successfully", token, role: user.role, name: user.name, email: user.email });
+    }
+} catch (err) {
+    console.error(err);
+    return res.status(500).json({ message: "Something went wrong" });
+}
+};
+
+export const signout = async (req, res) => {
+// Clear the cookie on logout
+    const cookieOptions = process.env.NODE_ENV === 'production'
+        ? { secure: true, sameSite: 'None', path: '/' }
+        : { secure: false, sameSite: 'Lax', path: '/' };
+    res.clearCookie('token', cookieOptions);
+    return res.status(200).json({ message: 'Logged out successfully' });
+};
+
+export const getUserProfile = async (req, res) => {
+try {
+    let user = null;
+
+    if (req.userId && mongoose.isValidObjectId(req.userId)) {
+        // Legacy JWT path: req.userId is a Mongo ObjectId string
+        user = await User.findById(req.userId).select('-password');
+    } else if (req.firebaseUser?.uid) {
+        // Firebase path: look up by firebaseUid field, fallback to email
+        user = await User.findOne({ firebaseUid: req.firebaseUser.uid }).select('-password');
+        if (!user && req.userEmail) {
+            user = await User.findOne({ email: req.userEmail }).select('-password');
+        }
+    } else if (req.userEmail) {
+        // Final fallback: lookup by email
+        user = await User.findOne({ email: req.userEmail }).select('-password');
+    }
+
+    if (!user) return res.status(404).json({ message: "User not found" });
+    res.json(user);
+} catch (err) {
+    console.error(err);
+    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,99 @@
+import { generateAIContent } from '../utils/aiHelper.js';
+import { extractLanguage, getLanguageName } from '../utils/aiOrchestrator.js';
+import dotenv from 'dotenv';
+import mongoose from 'mongoose';
+
+const notificationSchema = new mongoose.Schema({
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+    title: { type: String, required: true },
+    message: { type: String, required: true },
+    type: { type: String, default: 'general' },
+    read: { type: Boolean, default: false },
+    link: String,
+}, { timestamps: true });
+
+const Notification = mongoose.models.Notification || mongoose.model('Notification', notificationSchema);
+
+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" });
+    }
+};

backend/controllers/taskController.js

@@ -0,0 +1,107 @@
+// import axios from 'axios';
+import Task from '../models/task.model.js';
+// import dotenv from 'dotenv';
+
+export const createTask = async(req, res)=>{
+    try{
+        const {title, description, date, isCompleted} = req.body;
+        const userId = req.userId;
+        console.log("Received Date: ", date);
+
+        const task = new Task({title,description,date, isCompleted, user: userId})
+        await task.save();
+        res.status(201).json(task);
+    }catch(err){
+        res.status(500).json({message: "Failed to create Task",err});
+    }
+}
+
+export const getTasks = async(req, res)=>{
+    try{
+        const userId = req.userId;
+        const {date} = req.query;
+        console.log(date);
+        
+        const query = date? {date, user: userId} : {user: userId};// if date is provided filter tasks by date
+        const tasks = await Task.find(query);// fetch task with the query
+        res.status(200).json(tasks);
+    }catch(err){
+        res.status(500).json({message : "Failed to get tasks"});
+    }
+}
+
+export const getTask = async(req, res)=>{
+    try{
+        const {id} = req.params;
+        const userId = req.userId;
+        const task = await Task.findOne({_id: id, user: userId});
+        if(task){
+            res.status(201).json(task);
+        }else{
+            res.status(404).json({message: 'Task not found'});
+        }
+    }catch(err){
+        res.status(500).json({message: "Failed to fetch the task"});
+    }
+}
+
+export const getTaskByDate = async(req, res)=>{
+    try{
+        const userId = req.userId;
+        const {date} = req.params;
+        const tasks = await Task.find({date : new Date(date), user: userId});
+        res.status(200).json(tasks);
+    }catch(err){
+        res.status(500).json({message: "Failed to get task by date"}, err);
+    }
+}
+
+
+export const getMonthlyTaskStats = async (req, res) => {
+    try {
+        const { year, month } = req.query;
+        const userId = req.userId;
+        const startDate = new Date(year, month - 1, 1);
+        const endDate = new Date(year, month, 0);
+
+        const tasks = await Task.find({ date: { $gte: startDate, $lte: endDate }, user: userId });
+        const totalTasks = tasks.length;
+        const completedTasks = tasks.filter(task => task.isCompleted).length;
+        const remainingTasks = totalTasks - completedTasks;
+
+        res.status(200).json({ totalTasks, completedTasks, remainingTasks });
+    } catch (error) {
+        res.status(500).json({ message: 'Failed to get task statistics', error });
+    }
+};
+
+export const updateTask = async(req, res)=>{
+    try{
+        const {id} = req.params;
+        const userId = req.userId;
+        const {title, description, date, isCompleted} = req.body;
+        const updatedTask = await Task.findOneAndUpdate(
+            { _id: id, user: userId }, // Ensure the task belongs to the user
+            { title, description, date, isCompleted },
+            { new: true }
+        );
+        if (updatedTask) {
+            res.status(200).json(updatedTask);
+        } else {
+            res.status(404).json({ message: 'Task not found' });
+        }
+    }catch(err){
+        res.status(500).json({message: "Failed to update the task", err});
+    }
+}
+
+export const deleteTask = async(req, res)=>{
+    try{
+        const userId = req.userId;
+        const {id} = req.params;
+        await Task.findOneAndDelete({_id: id, user: userId});
+        res.status(200).json({message : "Deleted successfully"});
+    }catch(err){
+        res.status(500).json({message: "Failed to delete the task"});
+    }
+}