v3: Auto API key generation with Supabase + developer portal

Dockerfile

@@ -1,25 +1,11 @@
-# Use official Python slim image
 FROM python:3.11-slim
-
-# Set working directory
 WORKDIR /app
-
-# Install system dependencies for TensorFlow
-RUN apt-get update && apt-get install -y \
-    libhdf5-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first (for Docker cache efficiency)
+RUN apt-get update && apt-get install -y libhdf5-dev && rm -rf /var/lib/apt/lists/*
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy model files and API code
 COPY best_v6.keras .
 COPY class_names.json .
 COPY main.py .
-
-# Expose port
+COPY portal.html .
 EXPOSE 7860
-
-# Start the FastAPI server
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -10,10 +10,81 @@ app_port: 7860
 
 # 🌾 Crop Classifier API
 
-AI-powered crop classification API built on **EfficientNetB3 v6** (93.48% accuracy) + **LLaMA-3.2-90B Vision** expert verification.
+AI-powered REST API that classifies **50 crop varieties** from images using EfficientNetB3 (93.48% accuracy) + LLaMA-3.2-90B Vision expert verification.
 
-## Usage
+## 🔑 Get an API Key
 
-`POST /predict` with your image + `x-api-key` header.
+Contact the admin to request your free API key:
+- 📧 Email: **your-email@gmail.com**
+- Or open a [Discussion](https://huggingface.co/spaces/VDX-0/crop-classifier-api/discussions) on this Space
 
-See `/docs` for interactive Swagger UI.
+---
+
+## 📡 Base URL
+```
+https://vdx-0-crop-classifier-api.hf.space
+```
+
+## 🚀 Quick Start
+
+### JavaScript
+```javascript
+const formData = new FormData();
+formData.append("file", imageFile); // your image file
+
+const response = await fetch("https://vdx-0-crop-classifier-api.hf.space/predict", {
+  method: "POST",
+  headers: { "x-api-key": "YOUR_API_KEY_HERE" },
+  body: formData
+});
+
+const result = await response.json();
+console.log(result.final_answer.crop_name);    // "Wheat"
+console.log(result.final_answer.quality);      // "Excellent"
+console.log(result.final_answer.explanation);  // "Full description..."
+```
+
+### Python
+```python
+import requests
+
+with open("crop.jpg", "rb") as f:
+    res = requests.post(
+        "https://vdx-0-crop-classifier-api.hf.space/predict",
+        headers={"x-api-key": "YOUR_API_KEY_HERE"},
+        files={"file": f}
+    )
+print(res.json()["final_answer"])
+```
+
+### cURL
+```bash
+curl -X POST "https://vdx-0-crop-classifier-api.hf.space/predict" \
+  -H "x-api-key: YOUR_API_KEY_HERE" \
+  -F "file=@crop_image.jpg"
+```
+
+---
+
+## 📦 Response Example
+```json
+{
+  "final_answer": {
+    "crop_name": "Wheat",
+    "quality": "Excellent",
+    "market_grade": "Grade A",
+    "characteristics": "Golden stalks with dry grain heads...",
+    "explanation": "High quality mature wheat crop...",
+    "storage_tip": "Store in cool, dry place in sealed bags",
+    "confidence_label": "High"
+  }
+}
+```
+
+## ⚡ Endpoints
+| Endpoint | Description |
+|---|---|
+| `POST /predict` | Full analysis (model + AI expert) |
+| `POST /predict/fast` | Model only, instant response |
+| `GET /crops` | List all 50 supported crops |
+| `GET /docs` | Interactive API documentation |

main.py

@@ -1,141 +1,104 @@
 """
-Crop Classifier REST API  v2.0
-===============================
-FastAPI server wrapping the EfficientNetB3 crop classification model (v6).
-Supports 50 crop varieties with API key authentication.
-
-Improvements in v2:
-  - Richer LLaMA output: scientific name, market grade, storage tip, prediction accuracy
-  - Confidence labels (High / Medium / Low) on every prediction
-  - Combined final_verdict field
-  - Request ID + timestamp on every response
-  - /predict/fast endpoint (model only, no LLaMA) for speed-sensitive callers
+Crop Classifier REST API  v3.0
+================================
+Auto-generated API keys via Supabase.
+Each user registers once → gets a unique key → uses it forever.
 """
 
-from fastapi import FastAPI, File, UploadFile, HTTPException, Header, Depends, Query
+from fastapi import FastAPI, File, UploadFile, HTTPException, Header, Depends, BackgroundTasks
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel, EmailStr
 import numpy as np
-import json
-import os
+import json, os, io, time, logging, base64, uuid, secrets
+from datetime import datetime, timezone
 from PIL import Image
 import tensorflow as tf
 from tensorflow.keras.applications.efficientnet import preprocess_input
-import io
-import time
-import logging
-import base64
-import requests
-import uuid
-from datetime import datetime, timezone
+import requests as req_lib
+import httpx
 
-# ─────────────────────────────────────────────
-#  Logging
-# ─────────────────────────────────────────────
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
 logger = logging.getLogger(__name__)
 
-# ─────────────────────────────────────────────
-#  App
-# ─────────────────────────────────────────────
-app = FastAPI(
-    title="🌾 Crop Classifier API",
-    description=(
-        "AI-powered REST API to classify crop images into 50 varieties.\n\n"
-        "**Model:** EfficientNetB3 v6 (93.48% accuracy)\n"
-        "**AI Expert:** LLaMA-3.2-90B Vision (NVIDIA)\n\n"
-        "### How to use\n"
-        "1. Get an API key from the admin.\n"
-        "2. `POST /predict` with your image + `x-api-key` header.\n"
-        "3. Get structured JSON with crop name, quality, grade, storage tips.\n\n"
-        "### Endpoints\n"
-        "- `POST /predict` — Full analysis (model + LLaMA expert)\n"
-        "- `POST /predict/fast` — Model only (no LLaMA, instant response)\n"
-        "- `GET /crops` — List all 50 supported crops\n"
-    ),
-    version="2.0.0",
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+# ── Supabase config ─────────────────────────────────────────────────────────
+SUPABASE_URL = os.environ.get("SUPABASE_URL", "https://ykvatttsnpjrwqfhhysu.supabase.co")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY",
+    "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InlrdmF0dHRzbnBqcndxZmhoeXN1Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA0OTk5NjQsImV4cCI6MjA4NjA3NTk2NH0.5Njnh8NBEcPDddHjwv3CoUpCcAHu-ALNUQHQVdAdq-Y"
 )
+SB_HEADERS = {"apikey": SUPABASE_KEY, "Authorization": f"Bearer {SUPABASE_KEY}", "Content-Type": "application/json"}
+SB_TABLE   = f"{SUPABASE_URL}/rest/v1/crop_api_keys"
 
-# ─────────────────────────────────────────────
-#  API Keys
-# ─────────────────────────────────────────────
-def load_api_keys() -> dict:
-    raw = os.environ.get("API_KEYS", "")
-    keys = {}
-    if raw:
-        for entry in raw.split(","):
-            parts = entry.strip().split(":", 1)
-            if len(parts) == 2:
-                keys[parts[0]] = parts[1]
-    if not keys:
-        keys = {
-            "dev-test-key-12345": "Local Development",
-            "kisansetu-app-key-99": "KisanSetu WebApp",
-        }
-    return keys
+# ── In-memory key cache (refreshed every 60 seconds) ──────────────────────
+_key_cache: dict = {}        # {api_key: {name, email, id}}
+_cache_ts: float = 0.0
 
-VALID_API_KEYS: dict = load_api_keys()
+async def refresh_key_cache():
+    global _key_cache, _cache_ts
+    try:
+        async with httpx.AsyncClient() as client:
+            r = await client.get(SB_TABLE + "?is_active=eq.true&select=api_key,name,email,id",
+                                 headers=SB_HEADERS, timeout=10)
+            if r.status_code == 200:
+                _key_cache = {row["api_key"]: row for row in r.json()}
+                _cache_ts  = time.time()
+                logger.info(f"Key cache refreshed: {len(_key_cache)} active keys")
+    except Exception as e:
+        logger.warning(f"Key cache refresh failed: {e}")
 
+def get_key_info(api_key: str) -> dict | None:
+    return _key_cache.get(api_key)
 
-def validate_api_key(x_api_key: str = Header(..., description="Your API key")):
-    if x_api_key not in VALID_API_KEYS:
-        logger.warning(f"Rejected invalid API key: {x_api_key[:8]}...")
-        raise HTTPException(status_code=401, detail={
-            "error": "Unauthorized",
-            "message": "Invalid or missing API key.",
-        })
-    return VALID_API_KEYS[x_api_key]
+# ── App ──────────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="🌾 Crop Classifier API",
+    description=(
+        "AI-powered crop image classification API.\n\n"
+        "**Get your free API key** → visit `/portal` \n\n"
+        "**Docs** → `/docs`"
+    ),
+    version="3.0.0",
+)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True,
+                   allow_methods=["*"], allow_headers=["*"])
 
-# ─────────────────────────────────────────────
-#  Model Loading
-# ─────────────────────────────────────────────
+# ── Startup: load model + warm cache ─────────────────────────────────────────
 MODEL_PATH = os.environ.get("MODEL_PATH", "best_v6.keras")
 JSON_PATH  = os.environ.get("JSON_PATH",  "class_names.json")
 
 logger.info(f"Loading model: {MODEL_PATH}")
 model = tf.keras.models.load_model(MODEL_PATH)
-logger.info("Model loaded.")
-
 with open(JSON_PATH) as f:
     class_names: list = json.load(f)["class_names"]
-logger.info(f"Loaded {len(class_names)} classes.")
+logger.info(f"Model loaded. {len(class_names)} classes.")
+
+import asyncio
+@app.on_event("startup")
+async def startup():
+    await refresh_key_cache()
 
-# ─────────────────────────────────────────────
-#  Helpers
-# ─────────────────────────────────────────────
+# ── NVIDIA / LLaMA ───────────────────────────────────────────────────────────
 NVIDIA_API_KEY = os.environ.get(
     "NVIDIA_API_KEY",
     "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"
 )
 LLAMA_URL = "https://integrate.api.nvidia.com/v1/chat/completions"
 
-
+# ── Helpers ───────────────────────────────────────────────────────────────────
 def confidence_label(pct: float) -> str:
-    """Convert confidence % to human-readable label."""
-    if pct >= 70:  return "High"
-    if pct >= 40:  return "Medium"
-    return "Low"
-
+    return "High" if pct >= 70 else "Medium" if pct >= 40 else "Low"
 
 def preprocess_image(image_bytes: bytes) -> np.ndarray:
     try:
         image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
     except Exception:
-        raise HTTPException(status_code=422, detail="Cannot decode image. Upload a valid JPG/PNG/WEBP/BMP file.")
+        raise HTTPException(status_code=422, detail="Cannot decode image.")
     image = image.resize((224, 224))
     arr = np.expand_dims(np.array(image, dtype=np.float32), axis=0)
     return preprocess_input(arr)
 
-
 def compress_image(image_bytes: bytes) -> bytes:
-    """Resize to 768×768 JPEG-85 for LLaMA — balanced quality vs payload size."""
     try:
         img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
         img.thumbnail((768, 768))
@@ -145,211 +108,234 @@ def compress_image(image_bytes: bytes) -> bytes:
     except Exception:
         return image_bytes
 
-
 def call_llama_vision(image_bytes: bytes, top3_preds: list) -> dict:
-    """
-    Call NVIDIA LLaMA-3.2-90B Vision for expert crop analysis.
-    Returns structured fields + richer agronomic data.
-    """
     try:
-        compressed = compress_image(image_bytes)
-        img_b64 = base64.b64encode(compressed).decode("utf-8")
-
-        predictions_str = ", ".join(
-            f"{p['crop']} ({p['confidence_percent']}%)" for p in top3_preds
-        )
-
+        img_b64 = base64.b64encode(compress_image(image_bytes)).decode("utf-8")
+        predictions_str = ", ".join(f"{p['crop']} ({p['confidence_percent']}%)" for p in top3_preds)
         prompt = (
             "You are an expert agricultural scientist and crop quality inspector with 20 years of experience.\n"
             "Carefully analyze the crop or agricultural product shown in this image.\n\n"
             f"An automated vision model suggests it might be: {predictions_str}\n\n"
             "Respond ONLY in this exact format — no extra text, no preamble:\n\n"
-            "**Crop Name:** [Correct common name of the crop/product]\n"
-            "**Scientific Name:** [Latin/scientific name, or 'N/A' if unknown]\n"
-            "**Characteristics:** [Visual features: color, shape, texture, size, form]\n"
+            "**Crop Name:** [Correct common name]\n"
+            "**Scientific Name:** [Latin name, or 'N/A']\n"
+            "**Characteristics:** [Visual features: color, shape, texture, size]\n"
             "**Quality:** [Choose ONE: Premium, Excellent, Very Good, Good, Fair, or Bad]\n"
             "**Market Grade:** [Choose ONE: Grade A, Grade B, Grade C, or Ungraded]\n"
-            "**Prediction Accuracy:** [Is the model correct? Choose ONE: Correct, Partially Correct, or Incorrect]\n"
-            "**Storage Tip:** [One practical tip for storing or handling this crop]\n"
-            "**Explanation:** [2-3 sentences explaining your identification and quality assessment]"
+            "**Prediction Accuracy:** [Choose ONE: Correct, Partially Correct, or Incorrect]\n"
+            "**Storage Tip:** [One practical storage recommendation]\n"
+            "**Explanation:** [2-3 sentences on identification and quality]"
         )
-
         payload = {
             "model": "meta/llama-3.2-90b-vision-instruct",
             "messages": [{"role": "user", "content": [
                 {"type": "text", "text": prompt},
                 {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_b64}"}}
             ]}],
-            "max_tokens": 600,
-            "temperature": 0.3,   # lower = more consistent, structured output
-            "top_p": 0.9,
-            "stream": False
+            "max_tokens": 600, "temperature": 0.3, "top_p": 0.9, "stream": False
         }
-
         headers = {"Authorization": f"Bearer {NVIDIA_API_KEY}", "Accept": "application/json"}
-        resp = requests.post(LLAMA_URL, headers=headers, json=payload, timeout=60)
+        resp = req_lib.post(LLAMA_URL, headers=headers, json=payload, timeout=60)
         resp.raise_for_status()
         raw_text = resp.json()["choices"][0]["message"]["content"]
 
-        # Robust parser — strips leading bullets and ** markers before matching
-        fields = {
-            "crop_name": None,
-            "scientific_name": None,
-            "characteristics": None,
-            "quality": None,
-            "market_grade": None,
-            "prediction_accuracy": None,
-            "storage_tip": None,
-            "explanation": None,
-        }
-
+        fields = {"crop_name": None, "scientific_name": None, "characteristics": None,
+                  "quality": None, "market_grade": None, "prediction_accuracy": None,
+                  "storage_tip": None, "explanation": None}
         for line in raw_text.splitlines():
             line = line.strip()
-            if line.startswith("- ") or line.startswith("* "):
-                line = line[2:]
+            if line.startswith("- ") or line.startswith("* "): line = line[2:]
             clean = line.replace("**", "").strip()
             cl = clean.lower()
-
-            if cl.startswith("crop name:"):
-                fields["crop_name"] = clean.split(":", 1)[1].strip()
-            elif cl.startswith("scientific name:"):
-                fields["scientific_name"] = clean.split(":", 1)[1].strip()
-            elif cl.startswith("characteristics:"):
-                fields["characteristics"] = clean.split(":", 1)[1].strip()
-            elif cl.startswith("quality:"):
-                fields["quality"] = clean.split(":", 1)[1].strip()
-            elif cl.startswith("market grade:"):
-                fields["market_grade"] = clean.split(":", 1)[1].strip()
-            elif cl.startswith("prediction accuracy:"):
-                fields["prediction_accuracy"] = clean.split(":", 1)[1].strip()
-            elif cl.startswith("storage tip:"):
-                fields["storage_tip"] = clean.split(":", 1)[1].strip()
-            elif cl.startswith("explanation:"):
-                fields["explanation"] = clean.split(":", 1)[1].strip()
-
+            if   cl.startswith("crop name:"):         fields["crop_name"]          = clean.split(":",1)[1].strip()
+            elif cl.startswith("scientific name:"):   fields["scientific_name"]    = clean.split(":",1)[1].strip()
+            elif cl.startswith("characteristics:"):   fields["characteristics"]    = clean.split(":",1)[1].strip()
+            elif cl.startswith("quality:"):           fields["quality"]            = clean.split(":",1)[1].strip()
+            elif cl.startswith("market grade:"):      fields["market_grade"]       = clean.split(":",1)[1].strip()
+            elif cl.startswith("prediction accuracy:"):fields["prediction_accuracy"]= clean.split(":",1)[1].strip()
+            elif cl.startswith("storage tip:"):       fields["storage_tip"]        = clean.split(":",1)[1].strip()
+            elif cl.startswith("explanation:"):       fields["explanation"]        = clean.split(":",1)[1].strip()
         fields["raw"] = raw_text
         return fields
-
     except Exception as e:
-        logger.warning(f"LLaMA call failed: {e}")
+        logger.warning(f"LLaMA failed: {e}")
         return {"error": str(e), "raw": None}
 
-
 def build_final_answer(top3: list, ai: dict | None) -> dict:
-    """
-    The clean, user-facing final answer — crop name, quality, characteristics, explanation.
-    Sourced from LLaMA when available, falls back to model prediction.
-    """
     ai_ok = ai and ai.get("crop_name") and not ai.get("error")
     return {
-        "crop_name":       ai.get("crop_name")       if ai_ok else top3[0]["crop"],
-        "quality":         ai.get("quality")         if ai_ok else "Unavailable",
-        "market_grade":    ai.get("market_grade")    if ai_ok else "Unavailable",
-        "characteristics": ai.get("characteristics") if ai_ok else "Unavailable",
-        "explanation":     ai.get("explanation")     if ai_ok else "Unavailable",
-        "storage_tip":     ai.get("storage_tip")     if ai_ok else "Unavailable",
-        "confidence_label":confidence_label(top3[0]["confidence_percent"]),
+        "crop_name":        ai.get("crop_name")        if ai_ok else top3[0]["crop"],
+        "quality":          ai.get("quality")          if ai_ok else "Unavailable",
+        "market_grade":     ai.get("market_grade")     if ai_ok else "Unavailable",
+        "characteristics":  ai.get("characteristics")  if ai_ok else "Unavailable",
+        "explanation":      ai.get("explanation")      if ai_ok else "Unavailable",
+        "storage_tip":      ai.get("storage_tip")      if ai_ok else "Unavailable",
+        "confidence_label": confidence_label(top3[0]["confidence_percent"]),
     }
 
-# ─────────────────────────────────────────────
-#  Routes
-# ─────────────────────────────────────────────
+async def increment_usage(key_id: str):
+    """Background task: increment request counter + update last_used_at."""
+    try:
+        async with httpx.AsyncClient() as client:
+            await client.patch(
+                f"{SB_TABLE}?id=eq.{key_id}",
+                headers=SB_HEADERS,
+                json={"last_used_at": datetime.now(timezone.utc).isoformat(),
+                      "requests_count": None},  # use DB increment below
+                timeout=5
+            )
+            # Use raw SQL increment
+            await client.post(f"{SUPABASE_URL}/rest/v1/rpc/increment_usage",
+                              headers=SB_HEADERS, json={"row_id": key_id}, timeout=5)
+    except Exception:
+        pass  # non-critical
+
+# ── API Key Validation ────────────────────────────────────────────────────────
+async def validate_api_key(x_api_key: str = Header(..., description="Your API key")):
+    global _cache_ts
+    # Refresh cache if older than 60 seconds
+    if time.time() - _cache_ts > 60:
+        await refresh_key_cache()
+    info = get_key_info(x_api_key)
+    if not info:
+        raise HTTPException(status_code=401, detail={
+            "error": "Unauthorized",
+            "message": "Invalid API key. Get your free key at /portal"
+        })
+    return info
+
+# ── Registration Model ────────────────────────────────────────────────────────
+class RegisterRequest(BaseModel):
+    name:  str
+    email: str
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  ROUTES
+# ══════════════════════════════════════════════════════════════════════════════
 
 @app.get("/", tags=["Info"])
 def root():
     return {
-        "api": "Crop Classifier API",
-        "version": "2.0.0",
-        "model": "EfficientNetB3 v6",
-        "accuracy": "93.48%",
-        "supported_crops": len(class_names),
-        "status": "online",
-        "endpoints": {
-            "full_analysis": "POST /predict",
-            "fast_predict":  "POST /predict/fast",
-            "crop_list":     "GET /crops",
-            "docs":          "/docs",
-        }
+        "api": "Crop Classifier API", "version": "3.0.0",
+        "model": "EfficientNetB3 v6", "accuracy": "93.48%",
+        "supported_crops": len(class_names), "status": "online",
+        "get_api_key": "/portal",
+        "docs": "/docs",
     }
 
-
 @app.get("/health", tags=["Info"])
 def health():
     return {"status": "ok"}
 
-
 @app.get("/crops", tags=["Info"])
 def list_crops():
+    return {"total": len(class_names),
+            "crops": [n.replace("_"," ").title() for n in class_names]}
+
+
+# ── REGISTER: auto-generate API key ──────────────────────────────────────────
+@app.post("/register", tags=["API Key"])
+async def register(body: RegisterRequest):
+    """
+    ## Get your free API key
+
+    Submit your name and email to receive a unique API key instantly.
+    No manual approval needed.
+    """
+    # Check if email already has a key
+    try:
+        async with httpx.AsyncClient() as client:
+            check = await client.get(
+                f"{SB_TABLE}?email=eq.{body.email}&select=api_key,name",
+                headers=SB_HEADERS, timeout=10
+            )
+            if check.status_code == 200 and check.json():
+                existing = check.json()[0]
+                return {
+                    "success": True,
+                    "message": f"You already have an API key, {existing['name']}!",
+                    "api_key": existing["api_key"],
+                    "is_new": False,
+                }
+    except Exception:
+        pass
+
+    # Generate new unique key
+    new_key = "crop-" + secrets.token_urlsafe(20)
+
+    try:
+        async with httpx.AsyncClient() as client:
+            r = await client.post(SB_TABLE, headers={**SB_HEADERS, "Prefer": "return=representation"},
+                json={"api_key": new_key, "name": body.name, "email": body.email}, timeout=10)
+            if r.status_code not in (200, 201):
+                raise HTTPException(status_code=500, detail="Failed to save API key. Try again.")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Database error: {e}")
+
+    # Refresh cache immediately
+    await refresh_key_cache()
+
+    logger.info(f"New API key issued to {body.email} ({body.name}): {new_key[:12]}...")
     return {
-        "total": len(class_names),
-        "crops": [n.replace("_", " ").title() for n in class_names]
+        "success": True,
+        "message": f"Welcome, {body.name}! Your API key is ready.",
+        "api_key": new_key,
+        "is_new": True,
+        "usage": {
+            "endpoint": "https://vdx-0-crop-classifier-api.hf.space/predict",
+            "header": f"x-api-key: {new_key}",
+            "docs": "https://vdx-0-crop-classifier-api.hf.space/docs",
+        }
     }
 
 
+# ── Developer Portal ──────────────────────────────────────────────────────────
+@app.get("/portal", response_class=HTMLResponse, tags=["API Key"], include_in_schema=False)
+def portal():
+    """Beautiful developer portal to get an API key."""
+    with open("portal.html", "r") as f:
+        return f.read()
+
+
+# ── PREDICT (full) ────────────────────────────────────────────────────────────
 @app.post("/predict", tags=["Prediction"])
 async def predict(
-    file: UploadFile = File(..., description="Crop image (JPG/PNG/WEBP/BMP, max 10MB)"),
-    client_name: str = Depends(validate_api_key),
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    key_info: dict = Depends(validate_api_key),
 ):
-    """
-    ## Full Crop Analysis
-
-    Runs the EfficientNetB3 model **+** LLaMA Vision expert verification.
-
-    Returns:
-    - Top-3 model predictions with confidence labels
-    - AI expert: crop name, scientific name, quality, market grade, storage tip
-    - Final combined verdict
-    - Request ID + timestamp for traceability
-    """
+    """Full crop analysis: EfficientNetB3 model + LLaMA Vision expert."""
     request_id = str(uuid.uuid4())
     ts = datetime.now(timezone.utc).isoformat()
 
-    # Validate
-    allowed = {"image/jpeg", "image/png", "image/webp", "image/bmp", "image/jpg"}
-    if file.content_type and file.content_type not in allowed:
-        raise HTTPException(status_code=415, detail=f"Unsupported type: {file.content_type}. Use JPG/PNG/WEBP/BMP.")
-
     image_bytes = await file.read()
-    if not image_bytes:
-        raise HTTPException(status_code=422, detail="File is empty.")
-    if len(image_bytes) > 10 * 1024 * 1024:
-        raise HTTPException(status_code=413, detail="File too large. Max 10MB.")
+    if not image_bytes: raise HTTPException(422, "File is empty.")
+    if len(image_bytes) > 10*1024*1024: raise HTTPException(413, "Max 10MB.")
 
-    # Model inference
     t0 = time.time()
     preds = model.predict(preprocess_image(image_bytes), verbose=0)[0]
-    inference_ms = round((time.time() - t0) * 1000, 1)
+    inference_ms = round((time.time()-t0)*1000, 1)
 
     top3_idx = np.argsort(preds)[-3:][::-1]
-    top3 = [
-        {
-            "rank": i + 1,
-            "crop": class_names[idx].replace("_", " ").title(),
-            "confidence_percent": round(float(preds[idx]) * 100, 2),
-            "confidence_label": confidence_label(round(float(preds[idx]) * 100, 2)),
-        }
-        for i, idx in enumerate(top3_idx)
-    ]
+    top3 = [{"rank": i+1, "crop": class_names[idx].replace("_"," ").title(),
+              "confidence_percent": round(float(preds[idx])*100, 2),
+              "confidence_label": confidence_label(round(float(preds[idx])*100, 2))}
+             for i, idx in enumerate(top3_idx)]
 
-    logger.info(f"[{request_id[:8]}] [{client_name}] Model → {top3[0]['crop']} ({top3[0]['confidence_percent']}%) in {inference_ms}ms")
-
-    # LLaMA expert
     t1 = time.time()
-    logger.info(f"[{request_id[:8]}] Calling LLaMA Vision...")
     ai = call_llama_vision(image_bytes, top3)
-    llama_ms = round((time.time() - t1) * 1000, 1)
-    logger.info(f"[{request_id[:8]}] LLaMA done in {llama_ms}ms")
+    llama_ms = round((time.time()-t1)*1000, 1)
+
+    # Increment usage counter in background (non-blocking)
+    background_tasks.add_task(increment_usage, key_info["id"])
 
     return {
         "success": True,
         "request_id": request_id,
         "timestamp": ts,
-
-        # ── Final Answer (user-facing, all you need) ────────
         "final_answer": build_final_answer(top3, ai),
-
-        # ── Model prediction ────────────────────────────────
         "model_prediction": {
             "top_prediction": top3[0]["crop"],
             "confidence_percent": top3[0]["confidence_percent"],
@@ -357,73 +343,52 @@ async def predict(
             "top3": top3,
             "inference_time_ms": inference_ms,
         },
-
-        # ── LLaMA expert analysis ───────────────────────────
         "ai_expert_verification": {
-            "crop_name":          ai.get("crop_name"),
-            "scientific_name":    ai.get("scientific_name"),
-            "characteristics":    ai.get("characteristics"),
-            "quality":            ai.get("quality"),
-            "market_grade":       ai.get("market_grade"),
-            "prediction_accuracy":ai.get("prediction_accuracy"),
-            "storage_tip":        ai.get("storage_tip"),
-            "explanation":        ai.get("explanation"),
-            "llama_time_ms":      llama_ms,
-            "raw":                ai.get("raw"),
+            "crop_name":           ai.get("crop_name"),
+            "scientific_name":     ai.get("scientific_name"),
+            "characteristics":     ai.get("characteristics"),
+            "quality":             ai.get("quality"),
+            "market_grade":        ai.get("market_grade"),
+            "prediction_accuracy": ai.get("prediction_accuracy"),
+            "storage_tip":         ai.get("storage_tip"),
+            "explanation":         ai.get("explanation"),
+            "llama_time_ms":       llama_ms,
         },
-
         "model_version": "v6",
-        "request_by": client_name,
+        "request_by": key_info["name"],
     }
 
 
+# ── PREDICT FAST (model only) ─────────────────────────────────────────────────
 @app.post("/predict/fast", tags=["Prediction"])
 async def predict_fast(
-    file: UploadFile = File(..., description="Crop image (JPG/PNG/WEBP/BMP, max 10MB)"),
-    client_name: str = Depends(validate_api_key),
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    key_info: dict = Depends(validate_api_key),
 ):
-    """
-    ## Fast Crop Prediction (Model Only)
-
-    Runs **only** the EfficientNetB3 model — no LLaMA call.
-    Returns results in under 500ms. Use this when speed matters more than expert verification.
-    """
+    """Fast prediction — model only, no LLaMA. Response in <500ms."""
     request_id = str(uuid.uuid4())
-    ts = datetime.now(timezone.utc).isoformat()
-
     image_bytes = await file.read()
-    if not image_bytes:
-        raise HTTPException(status_code=422, detail="File is empty.")
-    if len(image_bytes) > 10 * 1024 * 1024:
-        raise HTTPException(status_code=413, detail="File too large. Max 10MB.")
+    if not image_bytes: raise HTTPException(422, "File is empty.")
 
     t0 = time.time()
     preds = model.predict(preprocess_image(image_bytes), verbose=0)[0]
-    inference_ms = round((time.time() - t0) * 1000, 1)
+    inference_ms = round((time.time()-t0)*1000, 1)
 
     top3_idx = np.argsort(preds)[-3:][::-1]
-    top3 = [
-        {
-            "rank": i + 1,
-            "crop": class_names[idx].replace("_", " ").title(),
-            "confidence_percent": round(float(preds[idx]) * 100, 2),
-            "confidence_label": confidence_label(round(float(preds[idx]) * 100, 2)),
-        }
-        for i, idx in enumerate(top3_idx)
-    ]
+    top3 = [{"rank": i+1, "crop": class_names[idx].replace("_"," ").title(),
+              "confidence_percent": round(float(preds[idx])*100, 2),
+              "confidence_label": confidence_label(round(float(preds[idx])*100, 2))}
+             for i, idx in enumerate(top3_idx)]
 
-    logger.info(f"[{request_id[:8]}] [FAST] [{client_name}] → {top3[0]['crop']} ({top3[0]['confidence_percent']}%) in {inference_ms}ms")
+    background_tasks.add_task(increment_usage, key_info["id"])
 
     return {
-        "success": True,
-        "request_id": request_id,
-        "timestamp": ts,
+        "success": True, "request_id": request_id,
         "mode": "fast (model only)",
         "top_prediction": top3[0]["crop"],
         "confidence_percent": top3[0]["confidence_percent"],
         "confidence_label": top3[0]["confidence_label"],
-        "top3": top3,
-        "inference_time_ms": inference_ms,
-        "model_version": "v6",
-        "request_by": client_name,
+        "top3": top3, "inference_time_ms": inference_ms,
+        "model_version": "v6", "request_by": key_info["name"],
     }

portal.html

@@ -0,0 +1,295 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+<title>🌾 Crop Classifier API — Developer Portal</title>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=Fira+Code:wght@400;500&display=swap" rel="stylesheet"/>
+<style>
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+  :root {
+    --green:  #22c55e;
+    --green2: #16a34a;
+    --bg:     #0a0f0d;
+    --card:   #111a14;
+    --border: #1f2e22;
+    --text:   #e2f0e6;
+    --muted:  #6b8f74;
+    --accent: #bbf7d0;
+  }
+  body { font-family: 'Inter', sans-serif; background: var(--bg); color: var(--text);
+         min-height: 100vh; }
+
+  /* ── Hero ── */
+  .hero { text-align: center; padding: 72px 24px 48px; position: relative; overflow: hidden; }
+  .hero::before {
+    content: ''; position: absolute; inset: 0;
+    background: radial-gradient(ellipse 80% 60% at 50% 0%, rgba(34,197,94,.15) 0%, transparent 70%);
+    pointer-events: none;
+  }
+  .badge { display: inline-block; background: rgba(34,197,94,.15); border: 1px solid rgba(34,197,94,.3);
+           color: var(--green); padding: 4px 14px; border-radius: 99px; font-size: 13px; font-weight: 500;
+           margin-bottom: 20px; }
+  .hero h1 { font-size: clamp(2rem, 5vw, 3.2rem); font-weight: 700; line-height: 1.15; margin-bottom: 16px; }
+  .hero h1 span { color: var(--green); }
+  .hero p { color: var(--muted); font-size: 1.1rem; max-width: 540px; margin: 0 auto 40px; }
+
+  /* ── Stats bar ── */
+  .stats { display: flex; justify-content: center; gap: 40px; flex-wrap: wrap;
+           padding: 24px; border-top: 1px solid var(--border); border-bottom: 1px solid var(--border);
+           background: rgba(255,255,255,.02); }
+  .stat { text-align: center; }
+  .stat-val { font-size: 1.6rem; font-weight: 700; color: var(--green); }
+  .stat-lbl { font-size: 12px; color: var(--muted); margin-top: 2px; }
+
+  /* ── Main layout ── */
+  .container { max-width: 900px; margin: 0 auto; padding: 48px 24px; }
+
+  /* ── Card ── */
+  .card { background: var(--card); border: 1px solid var(--border); border-radius: 16px;
+          padding: 36px; margin-bottom: 32px; }
+  .card h2 { font-size: 1.3rem; font-weight: 600; margin-bottom: 8px; }
+  .card .sub { color: var(--muted); font-size: 14px; margin-bottom: 28px; }
+
+  /* ── Form ── */
+  .form-group { margin-bottom: 20px; }
+  label { display: block; font-size: 14px; font-weight: 500; margin-bottom: 8px; color: var(--accent); }
+  input { width: 100%; background: rgba(255,255,255,.05); border: 1px solid var(--border);
+          border-radius: 10px; padding: 13px 16px; color: var(--text); font-size: 15px;
+          font-family: inherit; outline: none; transition: border-color .2s; }
+  input:focus { border-color: var(--green); }
+  input::placeholder { color: var(--muted); }
+  .btn { width: 100%; background: var(--green); color: #000; border: none; border-radius: 10px;
+         padding: 14px; font-size: 16px; font-weight: 600; cursor: pointer;
+         transition: background .2s, transform .1s; font-family: inherit; }
+  .btn:hover { background: var(--green2); }
+  .btn:active { transform: scale(0.99); }
+  .btn:disabled { opacity: .6; cursor: not-allowed; }
+
+  /* ── Result box ── */
+  #result { display: none; margin-top: 28px; }
+  .result-header { display: flex; align-items: center; gap: 10px; margin-bottom: 20px; }
+  .result-header svg { width: 28px; color: var(--green); flex-shrink: 0; }
+  .result-header h3 { font-size: 1.1rem; font-weight: 600; }
+  .key-box { background: rgba(34,197,94,.08); border: 1px solid rgba(34,197,94,.25);
+              border-radius: 12px; padding: 20px; }
+  .key-label { font-size: 12px; color: var(--muted); text-transform: uppercase; letter-spacing: .05em;
+               margin-bottom: 10px; }
+  .key-display { display: flex; align-items: center; gap: 12px; }
+  .key-text { font-family: 'Fira Code', monospace; font-size: 15px; color: var(--green);
+              flex: 1; word-break: break-all; }
+  .copy-btn { background: rgba(34,197,94,.15); border: 1px solid rgba(34,197,94,.3); color: var(--green);
+               border-radius: 8px; padding: 8px 16px; font-size: 13px; font-weight: 500;
+               cursor: pointer; white-space: nowrap; transition: background .2s; font-family: inherit; }
+  .copy-btn:hover { background: rgba(34,197,94,.25); }
+
+  /* ── Code tabs ── */
+  .tabs { display: flex; gap: 4px; margin-bottom: -1px; }
+  .tab { background: transparent; border: 1px solid var(--border); border-bottom: none;
+         color: var(--muted); padding: 8px 18px; border-radius: 8px 8px 0 0; font-size: 13px;
+         cursor: pointer; font-family: inherit; transition: all .15s; }
+  .tab.active { background: #1a2e1e; color: var(--green); border-color: var(--border); }
+  .code-panel { display: none; background: #0d1a10; border: 1px solid var(--border);
+                border-radius: 0 12px 12px 12px; padding: 20px; overflow-x: auto; }
+  .code-panel.active { display: block; }
+  pre { font-family: 'Fira Code', monospace; font-size: 13px; line-height: 1.7; color: #c9d9cb; white-space: pre; }
+  .kw  { color: #79c0ff; } .fn { color: #d2a8ff; } .str { color: #a5d6ff; }
+  .cm  { color: #6b8f74; font-style: italic; } .key { color: #ffa657; }
+
+  /* Endpoints table */
+  table { width: 100%; border-collapse: collapse; font-size: 14px; }
+  th { text-align: left; color: var(--muted); font-weight: 500; padding: 8px 12px;
+       border-bottom: 1px solid var(--border); }
+  td { padding: 12px 12px; border-bottom: 1px solid rgba(255,255,255,.05); }
+  td:first-child { font-family: 'Fira Code', monospace; color: var(--green); font-size: 13px; }
+  tr:last-child td { border-bottom: none; }
+
+  .error-msg { color: #f87171; background: rgba(248,113,113,.1); border: 1px solid rgba(248,113,113,.2);
+               border-radius: 8px; padding: 12px 16px; font-size: 14px; margin-top: 16px; }
+</style>
+</head>
+<body>
+
+<div class="hero">
+  <div class="badge">🌾 Free API · No Credit Card</div>
+  <h1>Crop Classifier <span>API</span></h1>
+  <p>Identify 50 crop varieties from images using AI. Get your free API key in seconds — no approval needed.</p>
+</div>
+
+<div class="stats">
+  <div class="stat"><div class="stat-val">50</div><div class="stat-lbl">Crop Varieties</div></div>
+  <div class="stat"><div class="stat-val">93.48%</div><div class="stat-lbl">Model Accuracy</div></div>
+  <div class="stat"><div class="stat-val">Free</div><div class="stat-lbl">Forever</div></div>
+  <div class="stat"><div class="stat-val">&lt;500ms</div><div class="stat-lbl">Fast Mode Speed</div></div>
+</div>
+
+<div class="container">
+
+  <!-- Get API Key Card -->
+  <div class="card">
+    <h2>🔑 Get Your Free API Key</h2>
+    <p class="sub">Enter your name and email — your unique key is generated instantly.</p>
+
+    <div class="form-group">
+      <label for="name">Your Name / App Name</label>
+      <input id="name" type="text" placeholder="e.g. My Farm App" autocomplete="off"/>
+    </div>
+    <div class="form-group">
+      <label for="email">Email Address</label>
+      <input id="email" type="email" placeholder="you@example.com"/>
+    </div>
+    <button class="btn" id="getKeyBtn" onclick="getKey()">Generate API Key →</button>
+    <div id="errorMsg" class="error-msg" style="display:none;"></div>
+
+    <div id="result">
+      <div class="result-header">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+          <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><polyline points="22 4 12 14.01 9 11.01"/>
+        </svg>
+        <h3 id="resultTitle">Your API key is ready!</h3>
+      </div>
+      <div class="key-box">
+        <div class="key-label">Your API Key</div>
+        <div class="key-display">
+          <div class="key-text" id="apiKeyDisplay"></div>
+          <button class="copy-btn" onclick="copyKey()">Copy</button>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Code Examples -->
+  <div class="card">
+    <h2>💻 Code Examples</h2>
+    <p class="sub">Copy the code for your language and replace <code style="color:var(--green)">YOUR_API_KEY</code>.</p>
+
+    <div class="tabs">
+      <button class="tab active" onclick="switchTab('js',this)">JavaScript</button>
+      <button class="tab" onclick="switchTab('py',this)">Python</button>
+      <button class="tab" onclick="switchTab('curl',this)">cURL</button>
+    </div>
+
+    <div class="code-panel active" id="tab-js"><pre><span class="cm">// Full analysis (crop name, quality, characteristics, explanation)</span>
+<span class="kw">const</span> formData = <span class="kw">new</span> <span class="fn">FormData</span>();
+formData.<span class="fn">append</span>(<span class="str">"file"</span>, imageFile); <span class="cm">// File from &lt;input type="file"&gt;</span>
+
+<span class="kw">const</span> response = <span class="kw">await</span> <span class="fn">fetch</span>(<span class="str">"https://vdx-0-crop-classifier-api.hf.space/predict"</span>, {
+  <span class="key">method</span>: <span class="str">"POST"</span>,
+  <span class="key">headers</span>: { <span class="str">"x-api-key"</span>: <span class="str">"YOUR_API_KEY"</span> },
+  <span class="key">body</span>: formData
+});
+
+<span class="kw">const</span> data = <span class="kw">await</span> response.<span class="fn">json</span>();
+
+<span class="cm">// Use final_answer — has everything you need</span>
+console.<span class="fn">log</span>(data.final_answer.<span class="key">crop_name</span>);       <span class="cm">// "Wheat"</span>
+console.<span class="fn">log</span>(data.final_answer.<span class="key">quality</span>);         <span class="cm">// "Excellent"</span>
+console.<span class="fn">log</span>(data.final_answer.<span class="key">characteristics</span>); <span class="cm">// "Golden stalks..."</span>
+console.<span class="fn">log</span>(data.final_answer.<span class="key">explanation</span>);     <span class="cm">// "Full description..."</span></pre></div>
+
+    <div class="code-panel" id="tab-py"><pre><span class="kw">import</span> requests
+
+<span class="kw">with</span> <span class="fn">open</span>(<span class="str">"crop.jpg"</span>, <span class="str">"rb"</span>) <span class="kw">as</span> f:
+    response = requests.<span class="fn">post</span>(
+        <span class="str">"https://vdx-0-crop-classifier-api.hf.space/predict"</span>,
+        headers={<span class="str">"x-api-key"</span>: <span class="str">"YOUR_API_KEY"</span>},
+        files={<span class="str">"file"</span>: f}
+    )
+
+data = response.<span class="fn">json</span>()
+answer = data[<span class="str">"final_answer"</span>]
+
+<span class="fn">print</span>(answer[<span class="str">"crop_name"</span>])       <span class="cm"># Wheat</span>
+<span class="fn">print</span>(answer[<span class="str">"quality"</span>])         <span class="cm"># Excellent</span>
+<span class="fn">print</span>(answer[<span class="str">"characteristics"</span>]) <span class="cm"># Golden stalks...</span>
+<span class="fn">print</span>(answer[<span class="str">"explanation"</span>])     <span class="cm"># Full description...</span></pre></div>
+
+    <div class="code-panel" id="tab-curl"><pre>curl -X POST <span class="str">"https://vdx-0-crop-classifier-api.hf.space/predict"</span> \
+  -H <span class="str">"x-api-key: YOUR_API_KEY"</span> \
+  -F <span class="str">"file=@/path/to/crop.jpg"</span></pre></div>
+  </div>
+
+  <!-- Endpoints table -->
+  <div class="card">
+    <h2>📡 Endpoints</h2>
+    <p class="sub">Base URL: <code style="color:var(--green)">https://vdx-0-crop-classifier-api.hf.space</code></p>
+    <table>
+      <thead><tr><th>Endpoint</th><th>Description</th></tr></thead>
+      <tbody>
+        <tr><td>POST /predict</td><td>Full analysis — model + LLaMA AI expert (~10s)</td></tr>
+        <tr><td>POST /predict/fast</td><td>Model only — instant response (&lt;500ms)</td></tr>
+        <tr><td>POST /register</td><td>Generate a new API key</td></tr>
+        <tr><td>GET /crops</td><td>List all 50 supported crop varieties</td></tr>
+        <tr><td>GET /docs</td><td>Interactive Swagger API documentation</td></tr>
+      </tbody>
+    </table>
+  </div>
+
+</div>
+
+<script>
+  let generatedKey = "";
+
+  async function getKey() {
+    const name  = document.getElementById("name").value.trim();
+    const email = document.getElementById("email").value.trim();
+    const err   = document.getElementById("errorMsg");
+    const btn   = document.getElementById("getKeyBtn");
+
+    err.style.display = "none";
+    if (!name)  { showError("Please enter your name."); return; }
+    if (!email) { showError("Please enter your email."); return; }
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) { showError("Please enter a valid email."); return; }
+
+    btn.disabled = true;
+    btn.textContent = "Generating...";
+
+    try {
+      const res = await fetch("/register", {
+        method: "POST",
+        headers: {"Content-Type": "application/json"},
+        body: JSON.stringify({name, email})
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.detail?.message || data.detail || "Failed");
+
+      generatedKey = data.api_key;
+      document.getElementById("apiKeyDisplay").textContent = data.api_key;
+      document.getElementById("resultTitle").textContent =
+        data.is_new ? `Welcome, ${name}! Your API key is ready.` : `Welcome back, ${name}! Here's your key.`;
+      document.getElementById("result").style.display = "block";
+      btn.textContent = "✓ Key Generated";
+
+    } catch(e) {
+      showError(e.message);
+      btn.disabled = false;
+      btn.textContent = "Generate API Key →";
+    }
+  }
+
+  function showError(msg) {
+    const err = document.getElementById("errorMsg");
+    err.textContent = msg;
+    err.style.display = "block";
+  }
+
+  function copyKey() {
+    navigator.clipboard.writeText(generatedKey);
+    const btn = document.querySelector(".copy-btn");
+    btn.textContent = "Copied!";
+    setTimeout(() => btn.textContent = "Copy", 2000);
+  }
+
+  function switchTab(lang, el) {
+    document.querySelectorAll(".tab").forEach(t => t.classList.remove("active"));
+    document.querySelectorAll(".code-panel").forEach(p => p.classList.remove("active"));
+    el.classList.add("active");
+    document.getElementById("tab-"+lang).classList.add("active");
+  }
+
+  document.getElementById("email").addEventListener("keydown", e => {
+    if (e.key === "Enter") getKey();
+  });
+</script>
+</body>
+</html>

requirements.txt

@@ -5,3 +5,4 @@ tensorflow==2.16.1
 pillow==10.3.0
 numpy==1.26.4
 python-dotenv==1.0.1
+httpx==0.27.0