feat: simplify to Hugging Face Vision Transformer model and reduce dependencies

app.py

@@ -1,643 +1,106 @@
-#!/usr/bin/env python3
-"""
-Optimized Food Recognition Backend
-Fast CLIP-based food identification + Open Food Facts nutrition
-"""
 
-import asyncio
-import aiohttp
-import json
-import logging
 import os
-import re
-import time
 from io import BytesIO
-from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple
-from contextlib import asynccontextmanager
-
-import torch
-from PIL import Image
-from transformers import CLIPProcessor, CLIPModel, AutoFeatureExtractor, AutoModelForImageClassification, pipeline
 
+import uvicorn
 from fastapi import FastAPI, File, UploadFile, HTTPException, Query
-from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field
-import uvicorn
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Configuration
-class Config:
-    """Application configuration"""
-    # Server Configuration
-    HOST = os.getenv("HOST", "0.0.0.0")
-    PORT = int(os.getenv("PORT", "8000"))
-
-    # Device Configuration
-    DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
-    # Open Food Facts API
-    OFF_API_BASE = "https://world.openfoodfacts.org/api/v0"
-    OFF_SEARCH_URL = "https://world.openfoodfacts.org/cgi/search.pl"
-    OFF_USER_AGENT = "FoodRecognitionApp/1.0 ([email protected])"
-
-    # Nutrition APIs - Load from environment variables
-    USDA_API_KEY = os.getenv("USDA_API_KEY", "kgw5ZaUGy92zoFoCzAo1pGq688u0jYXEA17ZlzO9")
-    NUTRITIONIX_APP_ID = os.getenv("NUTRITIONIX_APP_ID", "4224c603")
-    NUTRITIONIX_API_KEY = os.getenv("NUTRITIONIX_API_KEY", "3f4717bb1433fcbf57799a36318301ab")
-
-# Model Configuration - Switch between models by commenting/uncommenting the lines below
-MODEL_NAME = "nateraw/food"  # Specialized food classifier (high accuracy, currently active)
-# MODEL_NAME = "dwililiya/food101-model-classification"  # EfficientNet-B0, 101 specific foods, lighter than nateraw
-# MODEL_NAME = "google/mobilenet_v2_1.0_224"  # Google MobileNet v2 (general purpose, not food-specific)
-
-# Best Hugging Face models for food recognition
-FOOD_MODELS = {
-    "primary": MODEL_NAME,  # Currently selected model
-    "secondary": "google/vit-base-patch16-224",  # Vision Transformer
-    "fallback": "microsoft/resnet-50",  # ResNet for general classification
-    "food_specific": "Kaludi/food-category-classification-v2.0",  # Another food-specific model
-}
-
-config = Config()
-
-# Data Models
-class NutritionInfo(BaseModel):
-    calories: float = Field(..., description="Calories per 100g")
-    protein: float = Field(..., description="Protein in grams per 100g") 
-    fat: float = Field(..., description="Fat in grams per 100g")
-    carbs: float = Field(..., description="Carbohydrates in grams per 100g")
-    fiber: Optional[float] = Field(None, description="Fiber in grams per 100g")
-    sugar: Optional[float] = Field(None, description="Sugar in grams per 100g")
-    sodium: Optional[float] = Field(None, description="Sodium in mg per 100g")
-
-class FoodAnalysisResponse(BaseModel):
-    label: str = Field(..., description="Identified food name")
-    confidence: float = Field(..., description="Recognition confidence (0-1)")
-    nutrition: NutritionInfo = Field(..., description="Nutritional information")
-    alternatives: List[str] = Field(default=[], description="Alternative food predictions")
-    source: str = Field(..., description="Data source")
-    off_product_id: Optional[str] = Field(None, description="Open Food Facts product ID")
-
-class ErrorResponse(BaseModel):
-    error: str
-    detail: Optional[str] = None
-
-# Professional Food Recognition Model
-class FoodRecognitionModel:
-    """Professional food recognition using specialized Hugging Face models"""
-    
-    def __init__(self):
-        self.device = config.DEVICE
-        self.primary_model = None
-        self.secondary_model = None
-        self.food_pipeline = None
-        self._load_models()
-    
-    def _load_models(self):
-        """Load specialized food recognition models"""
-        try:
-            logger.info(f"Loading specialized food recognition models on {self.device}")
-            
-            # Load primary food-specific model
-            try:
-                logger.info(f"Loading primary food model: {FOOD_MODELS['primary']}")
-                self.food_pipeline = pipeline(
-                    "image-classification",
-                    model=FOOD_MODELS["primary"],
-                    device=0 if "cuda" in str(self.device) else -1
-                )
-                logger.info("✅ Primary food model loaded successfully")
-            except Exception as e:
-                logger.warning(f"Primary model failed: {e}, trying secondary...")
-                
-                # Fallback to secondary model
-                try:
-                    logger.info("Loading secondary food model: Kaludi/food-category-classification-v2.0")
-                    self.food_pipeline = pipeline(
-                        "image-classification", 
-                        model=FOOD_MODELS["food_specific"],
-                        device=0 if "cuda" in str(self.device) else -1
-                    )
-                    logger.info("✅ Secondary food model loaded successfully")
-                except Exception as e2:
-                    logger.warning(f"Secondary model failed: {e2}, using Vision Transformer...")
-                    
-                    # Final fallback to ViT
-                    self.food_pipeline = pipeline(
-                        "image-classification",
-                        model=FOOD_MODELS["secondary"],
-                        device=0 if "cuda" in str(self.device) else -1
-                    )
-                    logger.info("✅ Vision Transformer model loaded as fallback")
-            
-        except Exception as e:
-            logger.error(f"Failed to load any food recognition model: {e}")
-            raise
-    
-    
-    def recognize_food(self, image: Image.Image) -> Tuple[str, float, List[str]]:
-        """
-        Professional food recognition using specialized models
-        
-        Returns:
-            (food_name, confidence, alternatives)
-        """
-        try:
-            start_time = time.time()
-            
-            # Convert image if needed
-            if image.mode != 'RGB':
-                image = image.convert('RGB')
-            
-            # Use specialized food recognition pipeline
-            results = self.food_pipeline(image, top_k=5)
-            
-            if not results:
-                logger.warning("No food predictions returned")
-                return "unknown food", 0.1, []
-            
-            # Extract top prediction
-            top_result = results[0]
-            food_name = self._clean_food_label(top_result['label'])
-            confidence = top_result['score']
-            
-            # Get alternatives
-            alternatives = []
-            for result in results[1:]:
-                alt_name = self._clean_food_label(result['label'])
-                if alt_name != food_name:  # Avoid duplicates
-                    alternatives.append(alt_name)
-            
-            elapsed = time.time() - start_time
-            logger.info(f"🎯 Professional food recognition in {elapsed:.2f}s: {food_name} ({confidence:.3f})")
-            
-            return food_name, confidence, alternatives[:4]  # Return top 4 alternatives
-            
-        except Exception as e:
-            logger.error(f"Food recognition failed: {e}")
-            return "unknown food", 0.1, []
-    
-    def _clean_food_label(self, label: str) -> str:
-        """Clean food label from model output"""
-        # Remove common prefixes/suffixes from model labels
-        cleaned = label.lower().strip()
-        
-        # Remove model-specific prefixes
-        prefixes_to_remove = ['food_', 'dish_', 'meal_']
-        for prefix in prefixes_to_remove:
-            if cleaned.startswith(prefix):
-                cleaned = cleaned[len(prefix):]
-        
-        # Replace underscores with spaces
-        cleaned = cleaned.replace('_', ' ')
-        
-        # Remove extra spaces
-        cleaned = ' '.join(cleaned.split())
-        
-        return cleaned
+from PIL import Image
+from transformers import pipeline
 
-# Optimized Open Food Facts Client
-class FastNutritionClient:
-    """Fast nutrition data client with better error handling"""
+# --- Configuration ---
+MODEL_NAME = "google/vit-base-patch16-224"
 
-    def __init__(self):
-        self.session = None
-        self.timeout = aiohttp.ClientTimeout(total=5, connect=2)  # Very fast timeout
-    
-    async def __aenter__(self):
-        self.session = aiohttp.ClientSession(timeout=self.timeout)
-        return self
-    
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        if self.session:
-            await self.session.close()
-    
-    async def get_nutrition(self, food_name: str) -> Optional[Tuple[NutritionInfo, str, Optional[str]]]:
-        """
-        Nutrition data lookup from Open Food Facts only - NO FALLBACKS
-        
-        Returns:
-            (nutrition_info, source, product_id) or None if not found in OFF
-        """
-        try:
-            # Try multiple search strategies for better results
-            search_terms = self._generate_search_terms(food_name)
-            
-            for search_term in search_terms:
-                try:
-                    result = await asyncio.wait_for(self._search_off(search_term), timeout=2.0)
-                    if result:
-                        return result
-                except asyncio.TimeoutError:
-                    logger.debug(f"Timeout searching for '{search_term}'")
-                    continue
-                except Exception as e:
-                    logger.debug(f"Error searching for '{search_term}': {e}")
-                    continue
-            
-            # NO FALLBACK - return None if not found in Open Food Facts
-            logger.warning(f"No nutrition data found in Open Food Facts for '{food_name}'")
-            return None
-                
-        except Exception as e:
-            logger.warning(f"Nutrition lookup failed for '{food_name}': {e}")
-            return None
-    
-    def _generate_search_terms(self, food_name: str) -> List[str]:
-        """Generate multiple search terms for better matching"""
-        terms = []
-        
-        # Original term
-        terms.append(food_name.lower().strip())
-        
-        # Remove descriptive words for broader search
-        clean_term = food_name.lower()
-        remove_words = ["american", "fluffy", "stack of", "with butter", "with syrup", "breakfast"]
-        for word in remove_words:
-            clean_term = clean_term.replace(word, "").strip()
-        
-        if clean_term and clean_term != terms[0]:
-            terms.append(clean_term)
-        
-        # Extract main food word (first meaningful word)
-        words = clean_term.split()
-        if words:
-            main_word = words[0] if len(words[0]) > 3 else (words[1] if len(words) > 1 else words[0])
-            if main_word not in terms:
-                terms.append(main_word)
-        
-        return terms[:3]  # Limit to 3 attempts
-    
-    async def _search_off(self, search_term: str) -> Optional[Tuple[NutritionInfo, str, Optional[str]]]:
-        """Search Open Food Facts with single term"""
-        try:
-            params = {
-                "search_terms": search_term,
-                "search_simple": 1,
-                "action": "process", 
-                "json": 1,
-                "page_size": 5,
-                "sort_by": "popularity"
-            }
-            
-            headers = {"User-Agent": config.OFF_USER_AGENT}
-            
-            # Use asyncio.wait_for for additional timeout protection
-            search_task = self.session.get(config.OFF_SEARCH_URL, params=params, headers=headers)
-            
-            async with await asyncio.wait_for(search_task, timeout=3.0) as response:
-                if response.status != 200:
-                    return None
-                
-                data = await response.json()
-                products = data.get("products", [])
-                
-                # Find best product with nutrition data
-                for product in products[:3]:
-                    product_name = product.get("product_name", "unknown")
-                    logger.debug(f"Checking product: {product_name}")
-                    nutrition = self._extract_nutrition(product)
-                    if nutrition:
-                        logger.debug(f"Extracted nutrition: {nutrition.calories} kcal")
-                        if self._validate_nutrition(nutrition):
-                            product_id = product.get("code")
-                            logger.info(f"✅ Found nutrition for '{search_term}': {nutrition.calories} kcal")
-                            return nutrition, "Open Food Facts", product_id
-                        else:
-                            logger.debug(f"❌ Nutrition validation failed for {product_name}")
-                    else:
-                        logger.debug(f"❌ Could not extract nutrition from {product_name}")
-                
-        except asyncio.TimeoutError:
-            logger.debug(f"OFF search timed out for '{search_term}'")
-        except Exception as e:
-            logger.debug(f"OFF search failed for '{search_term}': {e}")
-        
-        return None
-    
-    def _safe_float(self, value) -> float:
-        """Safely convert value to float"""
-        if not value:
-            return 0.0
-        try:
-            if isinstance(value, str):
-                cleaned = value.replace(',', '.')
-                # Handle duplicated decimals like "0.120.12"
-                if cleaned.count('.') > 1:
-                    parts = cleaned.split('.')
-                    cleaned = f"{parts[0]}.{parts[1][:2]}"  # Take first 2 decimal places
-                return float(cleaned)
-            return float(value)
-        except (ValueError, TypeError):
-            return 0.0
-    
-    def _extract_nutrition(self, product: Dict) -> Optional[NutritionInfo]:
-        """Extract nutrition with improved validation"""
-        try:
-            nutriments = product.get("nutriments", {})
-            
-            # Get calories from multiple possible fields
-            calories = 0
-            for key in ["energy-kcal_100g", "energy_100g"]:
-                value = nutriments.get(key)
-                if value:
-                    if key == "energy_100g":  # kJ to kcal
-                        calories = self._safe_float(value) / 4.184
-                    else:
-                        calories = self._safe_float(value)
-                    break
-            
-            protein = self._safe_float(nutriments.get("proteins_100g", 0))
-            fat = self._safe_float(nutriments.get("fat_100g", 0))
-            carbs = self._safe_float(nutriments.get("carbohydrates_100g", 0))
-            
-            # Basic validation
-            if calories <= 0 or calories > 3000:
-                return None
-            
-            # Optional nutrients
-            fiber = self._safe_float(nutriments.get("fiber_100g")) or None
-            sugar = self._safe_float(nutriments.get("sugars_100g")) or None
-            sodium = self._safe_float(nutriments.get("sodium_100g")) or None
-            
-            # Convert sodium g to mg
-            if sodium and sodium > 0:
-                sodium = sodium * 1000 if sodium < 50 else sodium
-            
-            return NutritionInfo(
-                calories=calories,
-                protein=protein,
-                fat=fat,
-                carbs=carbs,
-                fiber=fiber,
-                sugar=sugar,
-                sodium=sodium
-            )
-            
-        except Exception as e:
-            logger.debug(f"Nutrition extraction failed: {e}")
-            return None
-    
-    def _validate_nutrition(self, nutrition: NutritionInfo) -> bool:
-        """Validate nutrition data makes sense"""
-        return (50 <= nutrition.calories <= 2000 and
-                0 <= nutrition.protein <= 100 and
-                0 <= nutrition.fat <= 100 and 
-                0 <= nutrition.carbs <= 100)
+# --- Helper Functions ---
+def load_model():
+    """Loads a specialized food recognition model from Hugging Face."""
+    try:
+        print(f"Loading model: {MODEL_NAME}...")
+        # Using 'image-classification' pipeline
+        # device=0 for CUDA, device=-1 for CPU
+        food_classifier = pipeline("image-classification", model=MODEL_NAME, device=-1)
+        print("Model loaded successfully.")
+        return food_classifier
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        raise
 
-# Global model instances
-food_model = None
+def is_image_file(file: UploadFile):
+    """Checks if the file is a supported image format (JPEG, PNG)."""
+    return file.content_type in ["image/jpeg", "image/png"]
 
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Initialize models on startup"""
-    global food_model
-    logger.info("🚀 Starting Fast Food Recognition Backend...")
-    
-    # Load optimized food recognition model
-    food_model = FoodRecognitionModel()
-    
-    logger.info("✅ Backend ready for fast food recognition!")
-    yield
-    
-    # Cleanup on shutdown
-    logger.info("🛑 Shutting down backend...")
+# --- Load Model on Application Startup ---
+model = load_model()
 
-# FastAPI app
+# --- FastAPI Application ---
 app = FastAPI(
-    title="Fast Food Recognition Backend", 
-    description="Optimized CLIP-based food identification with Open Food Facts nutrition",
-    version="3.0.0",
-    lifespan=lifespan
+    title="Food Scanner API",
+    description="API for recognizing food in images using a specialized Hugging Face model.",
+    version="2.1.0" # Version updated to reflect translation
 )
 
-# CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+@app.post("/analyze")
+async def analyze(file: UploadFile = File(...), top_alternatives: int = Query(3)):
+    """Receives an image, performs food detection, and returns the result in JSON format."""
+    if not file:
+        raise HTTPException(status_code=400, detail="No image sent.")
+
+    if not is_image_file(file):
+        raise HTTPException(status_code=400, detail="Unsupported image format. Use JPEG or PNG.")
 
-# Utility functions
-def validate_image(file: UploadFile) -> Image.Image:
-    """Validate and load uploaded image"""
     try:
-        image_data = file.file.read()
-        image = Image.open(BytesIO(image_data))
-        
-        # Convert to RGB if needed
-        if image.mode != 'RGB':
-            image = image.convert('RGB')
-        
-        return image
-        
-    except Exception as e:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Invalid image file: {str(e)}"
-        )
+        contents = await file.read()
+        image = Image.open(BytesIO(contents))
+    except Exception:
+        raise HTTPException(status_code=500, detail="Error reading the image.")
 
-async def validate_image_from_url(image_url: str) -> Image.Image:
-    """Validate and load image from URL"""
     try:
-        async with aiohttp.ClientSession() as session:
-            async with session.get(image_url) as response:
-                if response.status != 200:
-                    raise HTTPException(status_code=400, detail="Could not fetch image from URL")
-                
-                image_data = await response.read()
-                image = Image.open(BytesIO(image_data))
-                
-                if image.mode != 'RGB':
-                    image = image.convert('RGB')
-                
-                return image
-                
+        # Perform prediction
+        predictions = model(image, top_k=top_alternatives + 1) # +1 to have the main prediction and alternatives
     except Exception as e:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Invalid image URL: {str(e)}"
-        )
+        raise HTTPException(status_code=500, detail=f"Error during model prediction: {e}")
 
-# API Endpoints
-
-@app.get("/")
-async def root():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "message": "Fast Food Recognition Backend",
-        "version": "3.0.0",
-        "device": str(config.DEVICE)
-    }
+    if not predictions:
+        raise HTTPException(status_code=404, detail="The model failed to recognize food in the image.")
 
-@app.get("/health")
-async def health_check():
-    """Detailed health check"""
-    return {
-        "status": "healthy",
-        "model_loaded": food_model is not None,
-        "device": config.DEVICE,
-        "food_pipeline_loaded": food_model.food_pipeline is not None if food_model else False,
-        "model_type": "Professional Food Recognition Models"
-    }
+    # Process results
+    main_prediction = predictions[0]
 
-@app.post("/analyze", response_model=FoodAnalysisResponse)
-async def analyze_food_image(
-    file: UploadFile = File(..., description="Food image to analyze"),
-    top_alternatives: int = Query(3, ge=1, le=5, description="Number of alternative predictions")
-):
-    """
-    Fast food image analysis with optimized CLIP recognition
-    """
-    try:
-        start_time = time.time()
-        
-        # Validate and load image
-        image = validate_image(file)
-        logger.info(f"Image loaded in {time.time() - start_time:.2f}s")
-        
-        # Fast food recognition - always returns high confidence results
-        food_name, confidence, alternatives = food_model.recognize_food(image)
-        
-        # Get nutrition data
-        nutrition_start = time.time()
-        async with FastNutritionClient() as nutrition_client:
-            nutrition_result = await nutrition_client.get_nutrition(food_name)
-        
-        if not nutrition_result:
-            raise HTTPException(
-                status_code=422,
-                detail=f"No nutrition data found for '{food_name}'. Try a different image or food type."
-            )
-        
-        nutrition, source, product_id = nutrition_result
-        logger.info(f"Nutrition lookup completed in {time.time() - nutrition_start:.2f}s")
-        
-        total_time = time.time() - start_time
-        logger.info(f"🎯 Complete analysis in {total_time:.2f}s: {food_name} ({confidence:.3f})")
-        
-        return FoodAnalysisResponse(
-            label=food_name,
-            confidence=confidence,
-            nutrition=nutrition,
-            alternatives=alternatives[:top_alternatives],
-            source=source,
-            off_product_id=product_id
+    # --- NEW STEP: Confidence Threshold Check ---
+    CONFIDENCE_THRESHOLD = 0.5 # 50% confidence threshold
+    if main_prediction["score"] < CONFIDENCE_THRESHOLD:
+        raise HTTPException(
+            status_code=422, # Unprocessable Entity
+            detail=f"Food could not be recognized with sufficient confidence. The model is {main_prediction['score']:.0%} confident that this is a {main_prediction['label'].replace('_', ' ')}."
         )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Analysis failed: {e}")
-        raise HTTPException(status_code=500, detail=f"Internal analysis error: {str(e)}")
 
-@app.post("/analyze-url", response_model=FoodAnalysisResponse)  
-async def analyze_food_image_from_url(
-    image_url: str = Query(..., description="URL of food image to analyze"),
-    top_alternatives: int = Query(3, ge=1, le=5, description="Number of alternative predictions")
-):
-    """
-    Fast food image analysis from URL
-    """
-    try:
-        start_time = time.time()
-        
-        # Load image from URL
-        image = await validate_image_from_url(image_url)
-        
-        # Fast food recognition - always returns high confidence results
-        food_name, confidence, alternatives = food_model.recognize_food(image)
-        
-        # Get nutrition data
-        async with FastNutritionClient() as nutrition_client:
-            nutrition_result = await nutrition_client.get_nutrition(food_name)
-        
-        if not nutrition_result:
-            raise HTTPException(
-                status_code=422,
-                detail=f"No nutrition data found for '{food_name}'"
-            )
-        
-        nutrition, source, product_id = nutrition_result
-        
-        total_time = time.time() - start_time
-        logger.info(f"🎯 URL analysis completed in {total_time:.2f}s: {food_name}")
-        
-        return FoodAnalysisResponse(
-            label=food_name,
-            confidence=confidence,
-            nutrition=nutrition,
-            alternatives=alternatives[:top_alternatives],
-            source=source,
-            off_product_id=product_id
-        )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"URL analysis failed: {e}")
-        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+    alternatives = [p["label"] for p in predictions[1:]]
+    
+    # Clean up the label name (e.g., replace _ with a space)
+    label_name = main_prediction["label"].replace('_', ' ')
+
+    # Prepare the final response in the format expected by the frontend
+    final_response = {
+        "label": label_name,
+        "confidence": round(main_prediction["score"], 2),
+        # Bounding box is no longer available with this model
+        "bounding_box": None,
+        # Adding a dummy nutrition object to prevent the frontend from crashing
+        "nutrition": {
+            "calories": 0, "protein": 0, "fat": 0, "carbs": 0,
+            "fiber": 0, "sugar": 0, "sodium": 0
+        },
+        "alternatives": alternatives,
+        "source": f"Hugging Face ({MODEL_NAME})",
+        "off_product_id": None
+    }
 
-@app.get("/search-nutrition/{food_name}")
-async def search_nutrition_data(food_name: str):
-    """
-    Search for nutrition information for a specific food item
-    """
-    try:
-        async with FastNutritionClient() as nutrition_client:
-            nutrition_result = await nutrition_client.get_nutrition(food_name)
-            
-            if not nutrition_result:
-                raise HTTPException(
-                    status_code=404,
-                    detail=f"No nutrition data found for '{food_name}'"
-                )
-            
-            nutrition, source, product_id = nutrition_result
-            
-            return {
-                "food_name": food_name,
-                "nutrition": nutrition,
-                "source": source,
-                "off_product_id": product_id
-            }
-            
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Nutrition search failed: {e}")
-        raise HTTPException(status_code=500, detail=f"Search failed: {str(e)}")
+    return JSONResponse(content=final_response)
 
-# Global exception handler
-@app.exception_handler(Exception)
-async def global_exception_handler(request, exc):
-    logger.error(f"Global exception: {exc}")
-    return JSONResponse(
-        status_code=500,
-        content={
-            "error": "Internal server error",
-            "detail": "An unexpected error occurred"
-        }
-    )
+@app.get("/")
+def root():
+    return {"message": "Food Scanner API v2.1 is running. Send a POST request to /analyze for detection."}
 
+# --- Run the API ---
 if __name__ == "__main__":
-    # Create backend directory if it doesn't exist
-    backend_dir = Path(__file__).parent
-    backend_dir.mkdir(exist_ok=True)
-
-    # Run the server with configuration from Config
-    uvicorn.run(
-        "app:app",
-        host=config.HOST,
-        port=config.PORT,
-        reload=True,
-        log_level="info"
-    )
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -1,20 +1,6 @@
-# Core FastAPI and server requirements
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-
-# Machine Learning and Image Processing (optimized)
-torch>=2.0.0
-torchvision>=0.15.0
-Pillow>=10.0.0
-
-# Lightweight transformers for CLIP only
-transformers>=4.30.0
-
-# HTTP and API client
-aiohttp>=3.8.0
-
-# Data validation and serialization
-pydantic>=2.0.0
-
-# Utilities
-python-multipart>=0.0.6
+fastapi
+uvicorn
+python-multipart
+pillow
+torch
+transformers

yolov8n.pt

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