Deploy Crop Classifier API v2

.env.example

@@ -0,0 +1,10 @@
+# Copy this file to .env and fill in your values
+# Never commit your real .env to GitHub!
+
+# Comma-separated list of API keys in format: key:label
+# Example:
+API_KEYS=your-secret-key-here:KisanSetuApp,another-key-456:ExternalUser
+
+# Paths to model files (defaults to current directory)
+MODEL_PATH=best_v6.keras
+JSON_PATH=class_names.json

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,25 @@
+# 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)
+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
+EXPOSE 7860
+
+# Start the FastAPI server
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,19 @@
 ---
-title: Crop Classifier Api
-emoji: 👀
-colorFrom: red
+title: Crop Classifier API
+emoji: 🌾
+colorFrom: green
 colorTo: yellow
 sdk: docker
 pinned: false
-license: apache-2.0
-short_description: predict crop , its quality, and further info.
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🌾 Crop Classifier API
+
+AI-powered crop classification API built on **EfficientNetB3 v6** (93.48% accuracy) + **LLaMA-3.2-90B Vision** expert verification.
+
+## Usage
+
+`POST /predict` with your image + `x-api-key` header.
+
+See `/docs` for interactive Swagger UI.

best_v6.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed5ff4a253b2396abb9d5ec10a3c8fea4c42d05409d7c082b16f4ac28f5813f3
+size 161426146

class_names.json

@@ -0,0 +1,160 @@
+{
+  "class_names": [
+    "Almonds plant",
+    "Apples plant",
+    "Avocados plant",
+    "Bananas plant",
+    "Barley plant",
+    "Broccoli plant",
+    "Cabbages and other brassicas plant",
+    "Carrots and turnips plant",
+    "Cashew nuts plant",
+    "Cassava plant",
+    "Cauliflower plant",
+    "Chickpeas plant",
+    "Chili peppers and green peppers plant",
+    "Coconuts plant",
+    "Coffee (green) plant",
+    "Cotton lint plant",
+    "Cucumbers and gherkins plant",
+    "Dates plant",
+    "Eggplants (Aubergines) plant",
+    "Garlic plant",
+    "Ginger plant",
+    "Grapes plant",
+    "Groundnuts (Peanuts) plant",
+    "Jackfruit plant",
+    "Lemons and limes plant",
+    "Lentils plant",
+    "Maize (Corn) plant",
+    "Mangoes mangosteens guavas plant",
+    "Millet plant",
+    "Mustard seeds plant",
+    "Oats plant",
+    "Onions (dry) plant",
+    "Oranges plant",
+    "Papayas plant",
+    "Peas (Green) plant",
+    "Pineapples plant",
+    "Potatoes plant",
+    "Rice (Paddy) plant",
+    "Sorghum plant",
+    "Soybeans plant",
+    "Spinach plant",
+    "Strawberries plant",
+    "Sugar cane plant",
+    "Sunflower seeds plant",
+    "Sweet potatoes plant",
+    "Tea plant",
+    "Tomatoes plant",
+    "Turmeric plant",
+    "Watermelons plant",
+    "Wheat plant"
+  ],
+  "class_indices": {
+    "Almonds plant": 0,
+    "Apples plant": 1,
+    "Avocados plant": 2,
+    "Bananas plant": 3,
+    "Barley plant": 4,
+    "Broccoli plant": 5,
+    "Cabbages and other brassicas plant": 6,
+    "Carrots and turnips plant": 7,
+    "Cashew nuts plant": 8,
+    "Cassava plant": 9,
+    "Cauliflower plant": 10,
+    "Chickpeas plant": 11,
+    "Chili peppers and green peppers plant": 12,
+    "Coconuts plant": 13,
+    "Coffee (green) plant": 14,
+    "Cotton lint plant": 15,
+    "Cucumbers and gherkins plant": 16,
+    "Dates plant": 17,
+    "Eggplants (Aubergines) plant": 18,
+    "Garlic plant": 19,
+    "Ginger plant": 20,
+    "Grapes plant": 21,
+    "Groundnuts (Peanuts) plant": 22,
+    "Jackfruit plant": 23,
+    "Lemons and limes plant": 24,
+    "Lentils plant": 25,
+    "Maize (Corn) plant": 26,
+    "Mangoes mangosteens guavas plant": 27,
+    "Millet plant": 28,
+    "Mustard seeds plant": 29,
+    "Oats plant": 30,
+    "Onions (dry) plant": 31,
+    "Oranges plant": 32,
+    "Papayas plant": 33,
+    "Peas (Green) plant": 34,
+    "Pineapples plant": 35,
+    "Potatoes plant": 36,
+    "Rice (Paddy) plant": 37,
+    "Sorghum plant": 38,
+    "Soybeans plant": 39,
+    "Spinach plant": 40,
+    "Strawberries plant": 41,
+    "Sugar cane plant": 42,
+    "Sunflower seeds plant": 43,
+    "Sweet potatoes plant": 44,
+    "Tea plant": 45,
+    "Tomatoes plant": 46,
+    "Turmeric plant": 47,
+    "Watermelons plant": 48,
+    "Wheat plant": 49
+  },
+  "idx_to_class": {
+    "0": "Almonds plant",
+    "1": "Apples plant",
+    "2": "Avocados plant",
+    "3": "Bananas plant",
+    "4": "Barley plant",
+    "5": "Broccoli plant",
+    "6": "Cabbages and other brassicas plant",
+    "7": "Carrots and turnips plant",
+    "8": "Cashew nuts plant",
+    "9": "Cassava plant",
+    "10": "Cauliflower plant",
+    "11": "Chickpeas plant",
+    "12": "Chili peppers and green peppers plant",
+    "13": "Coconuts plant",
+    "14": "Coffee (green) plant",
+    "15": "Cotton lint plant",
+    "16": "Cucumbers and gherkins plant",
+    "17": "Dates plant",
+    "18": "Eggplants (Aubergines) plant",
+    "19": "Garlic plant",
+    "20": "Ginger plant",
+    "21": "Grapes plant",
+    "22": "Groundnuts (Peanuts) plant",
+    "23": "Jackfruit plant",
+    "24": "Lemons and limes plant",
+    "25": "Lentils plant",
+    "26": "Maize (Corn) plant",
+    "27": "Mangoes mangosteens guavas plant",
+    "28": "Millet plant",
+    "29": "Mustard seeds plant",
+    "30": "Oats plant",
+    "31": "Onions (dry) plant",
+    "32": "Oranges plant",
+    "33": "Papayas plant",
+    "34": "Peas (Green) plant",
+    "35": "Pineapples plant",
+    "36": "Potatoes plant",
+    "37": "Rice (Paddy) plant",
+    "38": "Sorghum plant",
+    "39": "Soybeans plant",
+    "40": "Spinach plant",
+    "41": "Strawberries plant",
+    "42": "Sugar cane plant",
+    "43": "Sunflower seeds plant",
+    "44": "Sweet potatoes plant",
+    "45": "Tea plant",
+    "46": "Tomatoes plant",
+    "47": "Turmeric plant",
+    "48": "Watermelons plant",
+    "49": "Wheat plant"
+  },
+  "num_classes": 50,
+  "img_size": 224
+}

main.py

@@ -0,0 +1,429 @@
+"""
+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
+"""
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Header, Depends, Query
+from fastapi.middleware.cors import CORSMiddleware
+import numpy as np
+import json
+import os
+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
+
+# ─────────────────────────────────────────────
+#  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=["*"],
+)
+
+# ─────────────────────────────────────────────
+#  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
+
+VALID_API_KEYS: dict = load_api_keys()
+
+
+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]
+
+# ─────────────────────────────────────────────
+#  Model Loading
+# ─────────────────────────────────────────────
+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.")
+
+# ─────────────────────────────────────────────
+#  Helpers
+# ─────────────────────────────────────────────
+NVIDIA_API_KEY = os.environ.get(
+    "NVIDIA_API_KEY",
+    "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"
+)
+LLAMA_URL = "https://integrate.api.nvidia.com/v1/chat/completions"
+
+
+def confidence_label(pct: float) -> str:
+    """Convert confidence % to human-readable label."""
+    if pct >= 70:  return "High"
+    if pct >= 40:  return "Medium"
+    return "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.")
+    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))
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG", quality=85, optimize=True)
+        return buf.getvalue()
+    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
+        )
+
+        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"
+            "**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]"
+        )
+
+        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
+        }
+
+        headers = {"Authorization": f"Bearer {NVIDIA_API_KEY}", "Accept": "application/json"}
+        resp = requests.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,
+        }
+
+        for line in raw_text.splitlines():
+            line = line.strip()
+            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()
+
+        fields["raw"] = raw_text
+        return fields
+
+    except Exception as e:
+        logger.warning(f"LLaMA call 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"]),
+    }
+
+# ─────────────────────────────────────────────
+#  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",
+        }
+    }
+
+
+@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]
+    }
+
+
+@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),
+):
+    """
+    ## 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
+    """
+    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.")
+
+    # Model inference
+    t0 = time.time()
+    preds = model.predict(preprocess_image(image_bytes), verbose=0)[0]
+    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)
+    ]
+
+    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")
+
+    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"],
+            "confidence_label": top3[0]["confidence_label"],
+            "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"),
+        },
+
+        "model_version": "v6",
+        "request_by": client_name,
+    }
+
+
+@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),
+):
+    """
+    ## 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.
+    """
+    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.")
+
+    t0 = time.time()
+    preds = model.predict(preprocess_image(image_bytes), verbose=0)[0]
+    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)
+    ]
+
+    logger.info(f"[{request_id[:8]}] [FAST] [{client_name}] → {top3[0]['crop']} ({top3[0]['confidence_percent']}%) in {inference_ms}ms")
+
+    return {
+        "success": True,
+        "request_id": request_id,
+        "timestamp": ts,
+        "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,
+    }

requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.110.0
+uvicorn[standard]==0.29.0
+python-multipart==0.0.9
+tensorflow==2.16.1
+pillow==10.3.0
+numpy==1.26.4
+python-dotenv==1.0.1