DEV

.env.example

@@ -1,8 +1,3 @@
 # Server Configuration
 PORT=8000
 HOST=0.0.0.0
-
-# API Keys (optional, already in code)
-USDA_API_KEY=USDA_API_KEY
-NUTRITIONIX_APP_ID=NUTRITIONIX_APP_ID
-NUTRITIONIX_API_KEY=NUTRITIONIX_API_KEY

DEPLOYMENT.md

@@ -1,451 +0,0 @@
-# 🚀 Food Recognition Backend - Deployment Guide
-
-Complete guide for deploying the food recognition API for **FREE** on various platforms.
-
----
-
-## 📋 Table of Contents
-1. [Quick Start](#quick-start)
-2. [Free Hosting Options](#free-hosting-options)
-3. [Deployment Instructions](#deployment-instructions)
-4. [Environment Variables](#environment-variables)
-5. [Testing Your Deployment](#testing-your-deployment)
-6. [Integration with Next.js](#integration-with-nextjs)
-
----
-
-## 🎯 Quick Start
-
-Before deploying, ensure you have:
-- ✅ Python 3.11+
-- ✅ Git repository (GitHub/GitLab)
-- ✅ Docker installed (for local testing)
-
----
-
-## 💰 Free Hosting Options
-
-### 🥇 **Option 1: Hugging Face Spaces** (RECOMMENDED)
-- **Cost**: 100% FREE
-- **Specs**: 2 vCPU, 16GB RAM
-- **Limits**: No request limits
-- **Cold Starts**: ~30-60s first request
-- **Best For**: ML models, unlimited testing
-
-### 🥈 **Option 2: Render**
-- **Cost**: FREE tier available
-- **Specs**: 512MB RAM, shared CPU
-- **Limits**: Spins down after 15min inactivity
-- **Cold Starts**: ~30-60s after sleep
-- **Best For**: Simple APIs with moderate usage
-
-### 🥉 **Option 3: Railway** (Limited Free)
-- **Cost**: $5 free credit/month
-- **Specs**: ~500 hours/month
-- **Limits**: Credit-based
-- **Best For**: Development/staging
-
-### ⚠️ **NOT Recommended (Too Restrictive)**
-- ❌ Vercel/Netlify - 50MB limit (model is 500MB+)
-- ❌ Heroku - No free tier anymore
-- ❌ AWS Lambda - 250MB deployment limit
-
----
-
-## 📦 Deployment Instructions
-
-### 🟢 Deploy to Hugging Face Spaces (BEST FREE OPTION)
-
-**Step 1: Create Account**
-```bash
-# Visit https://huggingface.co/join
-# Create free account
-```
-
-**Step 2: Create New Space**
-1. Go to https://huggingface.co/new-space
-2. **Name**: `food-recognition-api` (or your choice)
-3. **License**: MIT
-4. **SDK**: Docker
-5. **Hardware**: CPU (basic) - FREE ✅
-6. Click **Create Space**
-
-**Step 3: Prepare Files**
-
-Create `Dockerfile` (already included):
-```dockerfile
-FROM python:3.11-slim
-WORKDIR /app
-RUN apt-get update && apt-get install -y gcc g++ && rm -rf /var/lib/apt/lists/*
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-COPY app.py .
-EXPOSE 8000
-ENV PYTHONUNBUFFERED=1
-ENV PORT=8000
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"]
-```
-
-**Step 4: Push to Space**
-
-Option A: Web UI
-```bash
-# Zip your files: app.py, requirements.txt, Dockerfile
-# Upload via Hugging Face Space UI
-```
-
-Option B: Git (recommended)
-```bash
-# Clone your space
-git clone https://huggingface.co/spaces/YOUR_USERNAME/food-recognition-api
-cd food-recognition-api
-
-# Copy files
-cp /path/to/app.py .
-cp /path/to/requirements.txt .
-cp /path/to/Dockerfile .
-
-# Commit and push
-git add .
-git commit -m "Initial deployment"
-git push
-```
-
-**Step 5: Configure Environment**
-1. Go to Space Settings → Variables
-2. Add:
-   ```
-   PORT=7860
-   HOST=0.0.0.0
-   ```
-
-**Step 6: Get Your API URL**
-```
-https://YOUR_USERNAME-food-recognition-api.hf.space
-```
-
-**Build Time**: 5-10 minutes (PyTorch is large)
-
----
-
-### 🟡 Deploy to Render
-
-**Step 1: Create Account**
-- Visit https://render.com
-- Sign up with GitHub
-
-**Step 2: Create New Web Service**
-1. Click **New +** → **Web Service**
-2. Connect your GitHub repository
-3. Settings:
-   - **Name**: `food-recognition-api`
-   - **Environment**: Docker
-   - **Region**: Choose closest
-   - **Branch**: `main`
-   - **Dockerfile Path**: `./Dockerfile`
-
-**Step 3: Configure**
-- **Plan**: Free
-- **Environment Variables**:
-  ```
-  PORT=10000
-  USDA_API_KEY=your_key_here
-  NUTRITIONIX_APP_ID=your_id_here
-  NUTRITIONIX_API_KEY=your_key_here
-  ```
-
-**Step 4: Deploy**
-- Click **Create Web Service**
-- Wait 10-15 minutes for build
-
-**Your URL**: `https://food-recognition-api.onrender.com`
-
-⚠️ **Note**: Free tier sleeps after 15min inactivity. First request after sleep takes ~30-60s.
-
----
-
-### 🟠 Deploy to Railway (Limited Free)
-
-**Step 1: Create Account**
-- Visit https://railway.app
-- Sign up with GitHub
-
-**Step 2: Create New Project**
-1. Click **New Project**
-2. Select **Deploy from GitHub repo**
-3. Choose your repository
-
-**Step 3: Configure Service**
-1. Click your service
-2. Settings:
-   - **Root Directory**: `/` (or `/food_recognition_backend` if nested)
-   - **Custom Start Command**: Leave empty (uses Dockerfile)
-
-**Step 4: Environment Variables**
-```
-PORT=8000
-USDA_API_KEY=your_key_here
-NUTRITIONIX_APP_ID=your_id_here
-NUTRITIONIX_API_KEY=your_key_here
-```
-
-**Step 5: Generate Domain**
-- Settings → Networking → Generate Domain
-
-**Your URL**: `https://food-recognition-api-production.up.railway.app`
-
-💰 **Cost**: $5 free credit monthly (~500 hours)
-
----
-
-## 🔐 Environment Variables
-
-### Required Variables
-
-```bash
-# Server Configuration
-PORT=8000                    # Port for the API (auto-assigned by some hosts)
-HOST=0.0.0.0                 # Host binding
-
-# Optional: Nutrition API Keys (already have defaults)
-USDA_API_KEY=your_key_here
-NUTRITIONIX_APP_ID=your_id_here
-NUTRITIONIX_API_KEY=your_key_here
-```
-
-### Where to Set Variables
-
-**Hugging Face Spaces:**
-- Settings → Repository secrets
-
-**Render:**
-- Environment → Environment Variables
-
-**Railway:**
-- Variables tab
-
----
-
-## 🧪 Testing Your Deployment
-
-### 1. Health Check
-```bash
-curl https://YOUR_API_URL/health
-```
-
-Expected response:
-```json
-{
-  "status": "healthy",
-  "model_loaded": true,
-  "device": "cpu",
-  "food_pipeline_loaded": true,
-  "model_type": "Professional Food Recognition Models"
-}
-```
-
-### 2. Test Food Recognition
-```bash
-# Upload image
-curl -X POST https://YOUR_API_URL/analyze?top_alternatives=3 \
-  -F "file=@path/to/food_image.jpg"
-```
-
-Expected response:
-```json
-{
-  "label": "pizza",
-  "confidence": 0.95,
-  "nutrition": {
-    "calories": 266,
-    "protein": 11.0,
-    "fat": 10.0,
-    "carbs": 33.0,
-    "fiber": 2.3,
-    "sugar": 3.7,
-    "sodium": 598
-  },
-  "alternatives": ["flatbread", "focaccia"],
-  "source": "Open Food Facts"
-}
-```
-
-### 3. Test from URL
-```bash
-curl -X POST "https://YOUR_API_URL/analyze-url?image_url=https://example.com/food.jpg&top_alternatives=3"
-```
-
-### 4. Search Nutrition Only
-```bash
-curl https://YOUR_API_URL/search-nutrition/pizza
-```
-
----
-
-## 🔗 Integration with Next.js
-
-### Step 1: Update Environment Variables
-
-In your Next.js project, add to `.env`:
-
-```bash
-# Production Food Recognition API
-FOOD_RECOGNITION_API_URL=https://YOUR_API_URL
-```
-
-### Step 2: Update API Routes
-
-Your Next.js API routes are already configured to use this variable:
-
-```javascript
-// src/app/api/nutrition/analyze-food/route.js
-const FOOD_API_BASE_URL = process.env.FOOD_RECOGNITION_API_URL || "http://localhost:8000";
-```
-
-### Step 3: Deploy Next.js
-
-**On Vercel/Coolify:**
-1. Add environment variable:
-   ```
-   FOOD_RECOGNITION_API_URL=https://YOUR_USERNAME-food-recognition-api.hf.space
-   ```
-2. Deploy/Restart
-
-### Step 4: Test Integration
-
-From your Next.js app:
-```javascript
-const formData = new FormData();
-formData.append('file', imageFile);
-
-const response = await fetch('/api/nutrition/analyze-food', {
-  method: 'POST',
-  body: formData,
-});
-
-const result = await response.json();
-console.log(result.data.foodName); // "pizza"
-console.log(result.data.calories);  // 266
-```
-
----
-
-## ⚡ Performance Tips
-
-### 1. Reduce Cold Starts
-**Hugging Face Spaces:**
-- Upgrade to paid tier for always-on ($9/month) - optional
-
-**Render:**
-- Paid plan keeps service always on ($7/month) - optional
-- Free: Keep pinging `/health` every 10 minutes
-
-### 2. Implement Caching
-In Next.js, cache results:
-```javascript
-// Example with Redis/Upstash
-const cacheKey = `food_${imageHash}`;
-const cached = await redis.get(cacheKey);
-if (cached) return cached;
-
-// Call API only if not cached
-const result = await callFoodAPI();
-await redis.set(cacheKey, result, { ex: 86400 }); // 24h cache
-```
-
-### 3. Optimize Image Size
-Before sending to API:
-```javascript
-// Resize images to max 800x800px
-const resized = await sharp(imageBuffer)
-  .resize(800, 800, { fit: 'inside' })
-  .jpeg({ quality: 80 })
-  .toBuffer();
-```
-
----
-
-## 🐛 Troubleshooting
-
-### Build Fails - Out of Memory
-**Solution**: Reduce PyTorch size in `requirements.txt`:
-```txt
-torch>=2.0.0,<2.2.0  # Pin specific version
-```
-
-### API Timeout
-**Solution**: Increase timeout in Next.js:
-```javascript
-const response = await fetch(API_URL, {
-  method: 'POST',
-  body: formData,
-  signal: AbortSignal.timeout(30000), // 30s timeout
-});
-```
-
-### Model Not Loading
-**Solution**: Check logs for memory issues. Upgrade to paid tier or reduce model size.
-
-### 422 Error - No Nutrition Data
-**Solution**: This is expected for some foods. Implement fallback:
-```javascript
-if (response.status === 422) {
-  // Show manual input form
-  showManualInputForm();
-}
-```
-
----
-
-## 📊 Cost Comparison
-
-| Platform | Free Tier | Monthly Cost | RAM | Cold Start | Best For |
-|----------|-----------|--------------|-----|------------|----------|
-| **Hugging Face** | ✅ Unlimited | $0 | 16GB | ~30-60s | **Development & Production** |
-| **Render** | ✅ Yes | $0 | 512MB | ~30-60s | **Light Usage** |
-| **Railway** | ⚠️ Limited | $0 ($5 credit) | 2GB | None | **Testing** |
-| **Coolify** | ✅ Self-hosted | $0 (your server) | Custom | None | **Full Control** |
-
----
-
-## 🎯 Recommendation
-
-**For Production (Free):**
-1. 🥇 **Hugging Face Spaces** - Best free option, no limits
-2. 🥈 **Render** - Good if traffic is low (sleeps after 15min)
-
-**For Production (Paid):**
-1. 🥇 **Coolify** (Self-hosted) - Full control, $5-20/month
-2. 🥈 **Railway Pro** - Easy, $20/month
-3. 🥉 **Render Paid** - Simple, $7/month
-
----
-
-## 📝 Next Steps
-
-1. ✅ Choose hosting platform (Hugging Face recommended)
-2. ✅ Deploy using instructions above
-3. ✅ Test with `/health` endpoint
-4. ✅ Update `FOOD_RECOGNITION_API_URL` in Next.js
-5. ✅ Deploy Next.js with new env variable
-6. ✅ Test end-to-end integration
-
----
-
-## 🆘 Support
-
-If you encounter issues:
-1. Check logs on your hosting platform
-2. Test locally with Docker first
-3. Verify environment variables are set
-4. Check API URL is accessible
-
----
-
-## 📄 License
-
-MIT License - Free to use for personal and commercial projects.
-
----
-
-**Ready to deploy? Start with Hugging Face Spaces for the best free experience!** 🚀

app.py

@@ -1,770 +1,245 @@
 #!/usr/bin/env python3
 """
-🏆 ULTRA-OPTIMIZED Food Scanner API v10.0 - 99% Accuracy Edition
-===============================================================
+🎯 Zero-Shot Food Recognition API - CLIP Edition
+================================================
 
-Specijalizovani food recognition sistem sa ensemble pristupom za maksimalnu preciznost.
+Jednostavan i moćan food recognition sistem baziran na CLIP modelu.
 
-Ključne optimizacije:
-- 🎯 Specijalizovani food-only modeli umjesto generičkih
-- 🔄 Ensemble voting sa 3+ modela za maksimalnu preciznost  
-- 🚫 Non-food detection da se izbegnu glupe greške
-- 📊 Confidence threshold filtering
-- 🖼️ Napredni image preprocessing
-- 🏷️ Optimizovane Food-101 labele sa sinonimima
-- 🧠 Smart fallback logika
+Ključne mogućnosti:
+- 🌍 Zero-shot prepoznavanje - prepoznaje bilo šta bez dodatnog treninga
+- 🎯 Veliki spektar objekata - ne samo hrana, već sve
+- 🚀 Jednostavan i čist kod
+- 📊 Visoka preciznost sa CLIP-om
+- 🏷️ Customizabilne labele
+- ⚡ Brza inferenca
 
 Autor: AI Assistant
-Verzija: 10.0.0 - ULTRA OPTIMIZED
+Verzija: 11.0.0 - ZERO-SHOT CLIP EDITION
 """
 
 import os
-import io
-from io import BytesIO
-from typing import Optional, Dict, Any, List, Tuple
-import base64
-import re
-import requests
-import contextlib
 import logging
-from pathlib import Path
-import json
+from io import BytesIO
+from typing import Optional, Dict, Any, List
 
 import uvicorn
-from fastapi import FastAPI, File, UploadFile, HTTPException, Query
+from fastapi import FastAPI, File, UploadFile, HTTPException
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 
 # Image processing
-from PIL import Image, ImageEnhance, ImageFilter
-import numpy as np
-import albumentations as A
-
-# Deep learning
+from PIL import Image
 import torch
-import torch.nn.functional as F
-from transformers import (
-    CLIPProcessor, CLIPModel,
-    pipeline as hf_pipeline,
-    AutoImageProcessor, AutoModelForImageClassification
-)
-import timm
-from sklearn.ensemble import VotingClassifier
-from scipy.special import softmax
+from transformers import CLIPProcessor, CLIPModel
+
+# Nutrition lookup
+import requests
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# --- ULTRA CONFIGURATION ---
-# Ensemble modeli za maksimalnu preciznost
-FOOD_MODELS = {
-    "primary": "Kaludi/food-category-classification-v2.0",  # Specijalizovani food model
-    "secondary": "nateraw/food",  # Backup food model
-    "tertiary": "microsoft/resnet-50",  # General vision model za fallback
-}
-
-# CLIP za non-food detection i fallback
+# --- CONFIGURATION ---
+# CLIP model - najbolji za zero-shot classification
 CLIP_MODEL_NAME = "openai/clip-vit-large-patch14"
-
-# Confidence thresholds
-MIN_CONFIDENCE_THRESHOLD = 0.15  # Minimum confidence za bilo koji rezultat
-HIGH_CONFIDENCE_THRESHOLD = 0.7  # Visoka sigurnost
-ENSEMBLE_AGREEMENT_THRESHOLD = 0.6  # Koliko se modeli moraju slagati
-
-# Non-food detection keywords
-NON_FOOD_KEYWORDS = [
-    "bottle", "water", "drink", "beverage", "liquid", "glass", "cup", "mug",
-    "plate", "bowl", "dish", "utensil", "fork", "knife", "spoon",
-    "table", "cloth", "napkin", "paper", "plastic", "metal",
-    "person", "hand", "face", "body", "clothing", "shirt", "pants",
-    "background", "wall", "floor", "ceiling", "furniture", "chair",
-    "electronic", "phone", "computer", "screen", "device",
-    "animal", "pet", "dog", "cat", "bird",
-    "plant", "flower", "tree", "leaf", "grass",
-    "vehicle", "car", "truck", "bike", "motorcycle",
-    "building", "house", "room", "kitchen", "bathroom"
+MIN_CONFIDENCE = 0.15
+
+# Food-101 categories za food recognition
+FOOD_CATEGORIES = [
+    "apple pie", "baby back ribs", "baklava", "beef carpaccio", "beef tartare",
+    "beet salad", "beignets", "bibimbap", "bread pudding", "breakfast burrito",
+    "bruschetta", "caesar salad", "cannoli", "caprese salad", "carrot cake",
+    "ceviche", "cheesecake", "cheese plate", "chicken curry", "chicken quesadilla",
+    "chicken wings", "chocolate cake", "chocolate mousse", "churros", "clam chowder",
+    "club sandwich", "crab cakes", "creme brulee", "croque madame", "cup cakes",
+    "deviled eggs", "donuts", "dumplings", "edamame", "eggs benedict",
+    "escargots", "falafel", "filet mignon", "fish and chips", "foie gras",
+    "french fries", "french onion soup", "french toast", "fried calamari", "fried rice",
+    "frozen yogurt", "garlic bread", "gnocchi", "greek salad", "grilled cheese sandwich",
+    "grilled salmon", "guacamole", "gyoza", "hamburger", "hot and sour soup",
+    "hot dog", "huevos rancheros", "hummus", "ice cream", "lasagna",
+    "lobster bisque", "lobster roll sandwich", "macaroni and cheese", "macarons", "miso soup",
+    "mussels", "nachos", "omelette", "onion rings", "oysters",
+    "pad thai", "paella", "pancakes", "panna cotta", "peking duck",
+    "pho", "pizza", "pork chop", "poutine", "prime rib",
+    "pulled pork sandwich", "ramen", "ravioli", "red velvet cake", "risotto",
+    "samosa", "sashimi", "scallops", "seaweed salad", "shrimp and grits",
+    "spaghetti bolognese", "spaghetti carbonara", "spring rolls", "steak", "strawberry shortcake",
+    "sushi", "tacos", "takoyaki", "tiramisu", "tuna tartare", "waffles"
 ]
 
-# --- Helper Functions ---
+
 def select_device() -> str:
-    """Odabire najbolji dostupni uređaj: CUDA > MPS (Apple) > CPU."""
+    """Odabire najbolji dostupni uređaj."""
     if torch.cuda.is_available():
         return "cuda"
-    try:
-        if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-            return "mps"
-    except Exception:
-        pass
+    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return "mps"
     return "cpu"
 
-def select_dtype(device: str):
-    """Odabire optimalni dtype za dati uređaj."""
-    if device == "cuda":
-        return torch.float16
-    if device == "mps":
-        return torch.float16
-    return torch.float32
-
-def autocast_context(device: str, dtype):
-    """Vraća odgovarajući autocast kontekst."""
-    if device in ("cuda", "cpu", "mps"):
-        try:
-            return torch.autocast(device_type=device, dtype=dtype)
-        except Exception:
-            return contextlib.nullcontext()
-    return contextlib.nullcontext()
 
-def get_optimized_food101_labels() -> Dict[str, List[str]]:
-    """
-    Vraća optimizovane Food-101 labele sa sinonimima i varijantama.
-    Ovo pomaže u boljem mapiranju rezultata modela.
+class ZeroShotFoodClassifier:
     """
-    labels_with_synonyms = {
-        "apple pie": ["apple pie", "apple tart", "apple dessert"],
-        "baby back ribs": ["baby back ribs", "pork ribs", "barbecue ribs", "bbq ribs"],
-        "baklava": ["baklava", "phyllo pastry", "honey pastry"],
-        "beef carpaccio": ["beef carpaccio", "raw beef", "carpaccio"],
-        "beef tartare": ["beef tartare", "steak tartare", "raw beef"],
-        "beet salad": ["beet salad", "beetroot salad", "beet"],
-        "beignets": ["beignets", "donut", "fried dough"],
-        "bibimbap": ["bibimbap", "korean rice bowl", "mixed rice"],
-        "bread pudding": ["bread pudding", "pudding"],
-        "breakfast burrito": ["breakfast burrito", "burrito", "wrap"],
-        "bruschetta": ["bruschetta", "toast", "bread"],
-        "caesar salad": ["caesar salad", "salad", "lettuce"],
-        "cannoli": ["cannoli", "italian pastry", "pastry"],
-        "caprese salad": ["caprese salad", "mozzarella tomato", "salad"],
-        "carrot cake": ["carrot cake", "cake", "dessert"],
-        "ceviche": ["ceviche", "raw fish", "seafood"],
-        "cheesecake": ["cheesecake", "cake", "dessert"],
-        "cheese plate": ["cheese plate", "cheese", "cheese board"],
-        "chicken curry": ["chicken curry", "curry", "chicken"],
-        "chicken quesadilla": ["chicken quesadilla", "quesadilla", "tortilla"],
-        "chicken wings": ["chicken wings", "wings", "chicken"],
-        "chocolate cake": ["chocolate cake", "cake", "chocolate dessert"],
-        "chocolate mousse": ["chocolate mousse", "mousse", "chocolate dessert"],
-        "churros": ["churros", "fried dough", "spanish pastry"],
-        "clam chowder": ["clam chowder", "soup", "seafood soup"],
-        "club sandwich": ["club sandwich", "sandwich"],
-        "crab cakes": ["crab cakes", "crab", "seafood"],
-        "creme brulee": ["creme brulee", "custard", "dessert"],
-        "croque madame": ["croque madame", "sandwich", "french sandwich"],
-        "cup cakes": ["cupcakes", "muffin", "small cake"],
-        "deviled eggs": ["deviled eggs", "eggs", "egg"],
-        "donuts": ["donuts", "donut", "doughnut"],
-        "dumplings": ["dumplings", "dumpling", "steamed bun"],
-        "edamame": ["edamame", "soybean", "beans"],
-        "eggs benedict": ["eggs benedict", "eggs", "poached eggs"],
-        "escargots": ["escargots", "snails", "french appetizer"],
-        "falafel": ["falafel", "chickpea", "middle eastern"],
-        "filet mignon": ["filet mignon", "steak", "beef"],
-        "fish and chips": ["fish and chips", "fried fish", "fish"],
-        "foie gras": ["foie gras", "liver", "pate"],
-        "french fries": ["french fries", "fries", "potato", "chips"],
-        "french onion soup": ["french onion soup", "onion soup", "soup"],
-        "french toast": ["french toast", "toast", "bread"],
-        "fried calamari": ["fried calamari", "calamari", "squid", "seafood"],
-        "fried rice": ["fried rice", "rice", "asian rice"],
-        "frozen yogurt": ["frozen yogurt", "yogurt", "ice cream"],
-        "garlic bread": ["garlic bread", "bread", "toast"],
-        "gnocchi": ["gnocchi", "pasta", "potato pasta"],
-        "greek salad": ["greek salad", "salad", "mediterranean salad"],
-        "grilled cheese sandwich": ["grilled cheese", "cheese sandwich", "sandwich"],
-        "grilled salmon": ["grilled salmon", "salmon", "fish"],
-        "guacamole": ["guacamole", "avocado", "dip"],
-        "gyoza": ["gyoza", "dumpling", "potsticker"],
-        "hamburger": ["hamburger", "burger", "cheeseburger"],
-        "hot and sour soup": ["hot and sour soup", "soup", "asian soup"],
-        "hot dog": ["hot dog", "sausage", "frankfurter"],
-        "huevos rancheros": ["huevos rancheros", "eggs", "mexican eggs"],
-        "hummus": ["hummus", "chickpea dip", "dip"],
-        "ice cream": ["ice cream", "gelato", "frozen dessert"],
-        "lasagna": ["lasagna", "pasta", "italian pasta"],
-        "lobster bisque": ["lobster bisque", "soup", "seafood soup"],
-        "lobster roll sandwich": ["lobster roll", "lobster sandwich", "seafood"],
-        "macaroni and cheese": ["mac and cheese", "macaroni", "pasta"],
-        "macarons": ["macarons", "macaron", "french cookie"],
-        "miso soup": ["miso soup", "soup", "japanese soup"],
-        "mussels": ["mussels", "shellfish", "seafood"],
-        "nachos": ["nachos", "chips", "tortilla chips"],
-        "omelette": ["omelette", "omelet", "eggs"],
-        "onion rings": ["onion rings", "fried onion", "onion"],
-        "oysters": ["oysters", "shellfish", "seafood"],
-        "pad thai": ["pad thai", "thai noodles", "noodles"],
-        "paella": ["paella", "spanish rice", "rice"],
-        "pancakes": ["pancakes", "pancake", "breakfast"],
-        "panna cotta": ["panna cotta", "dessert", "custard"],
-        "peking duck": ["peking duck", "duck", "chinese duck"],
-        "pho": ["pho", "vietnamese soup", "noodle soup"],
-        "pizza": ["pizza", "italian pizza", "pie"],
-        "pork chop": ["pork chop", "pork", "meat"],
-        "poutine": ["poutine", "fries", "canadian fries"],
-        "prime rib": ["prime rib", "beef", "roast beef"],
-        "pulled pork sandwich": ["pulled pork", "pork sandwich", "sandwich"],
-        "ramen": ["ramen", "noodles", "japanese noodles"],
-        "ravioli": ["ravioli", "pasta", "stuffed pasta"],
-        "red velvet cake": ["red velvet cake", "cake", "red cake"],
-        "risotto": ["risotto", "rice", "italian rice"],
-        "samosa": ["samosa", "indian pastry", "fried pastry"],
-        "sashimi": ["sashimi", "raw fish", "japanese fish"],
-        "scallops": ["scallops", "shellfish", "seafood"],
-        "seaweed salad": ["seaweed salad", "seaweed", "salad"],
-        "shrimp and grits": ["shrimp and grits", "shrimp", "grits"],
-        "spaghetti bolognese": ["spaghetti bolognese", "pasta", "spaghetti"],
-        "spaghetti carbonara": ["spaghetti carbonara", "pasta", "carbonara"],
-        "spring rolls": ["spring rolls", "rolls", "vietnamese rolls"],
-        "steak": ["steak", "beef", "grilled beef"],
-        "strawberry shortcake": ["strawberry shortcake", "shortcake", "strawberry cake"],
-        "sushi": ["sushi", "japanese food", "raw fish"],
-        "tacos": ["tacos", "taco", "mexican food"],
-        "takoyaki": ["takoyaki", "octopus balls", "japanese snack"],
-        "tiramisu": ["tiramisu", "italian dessert", "coffee dessert"],
-        "tuna tartare": ["tuna tartare", "raw tuna", "tuna"],
-        "waffles": ["waffles", "waffle", "breakfast"]
-    }
+    Zero-shot food classifier baziran na CLIP modelu.
     
-    return labels_with_synonyms
-
-def advanced_image_preprocessing(image: Image.Image) -> List[Image.Image]:
+    CLIP (Contrastive Language-Image Pre-training) je model koji može
+    prepoznati bilo koji objekat bez dodatnog treninga - jednostavno mu
+    kažeš šta da traži i on to prepoznaje.
     """
-    Napredni image preprocessing koji generiše multiple varijante slike
-    za bolju preciznost ensemble modela.
-    """
-    # Konvertuj u RGB ako nije
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-    
-    # Lista preprocessovanih slika
-    processed_images = []
-    
-    # 1. Originalna slika (resize)
-    original = image.resize((224, 224), Image.Resampling.LANCZOS)
-    processed_images.append(original)
     
-    # 2. Enhanced contrast
-    enhancer = ImageEnhance.Contrast(original)
-    enhanced = enhancer.enhance(1.2)
-    processed_images.append(enhanced)
-    
-    # 3. Enhanced brightness
-    enhancer = ImageEnhance.Brightness(original)
-    brightened = enhancer.enhance(1.1)
-    processed_images.append(brightened)
-    
-    # 4. Sharpened
-    sharpened = original.filter(ImageFilter.SHARPEN)
-    processed_images.append(sharpened)
-    
-    # 5. Center crop (fokus na centar)
-    width, height = original.size
-    crop_size = min(width, height)
-    left = (width - crop_size) // 2
-    top = (height - crop_size) // 2
-    right = left + crop_size
-    bottom = top + crop_size
-    center_cropped = original.crop((left, top, right, bottom)).resize((224, 224))
-    processed_images.append(center_cropped)
-    
-    return processed_images
-
-def is_non_food_object(text: str) -> bool:
-    """Proverava da li je objekat non-food na osnovu ključnih reči."""
-    text_lower = text.lower()
-    return any(keyword in text_lower for keyword in NON_FOOD_KEYWORDS)
-
-class UltraFoodClassifier:
-    """
-    Ultra-optimizovani food classifier sa ensemble pristupom.
-    Kombinuje više specijalizovanih modela za maksimalnu preciznost.
-    """
-    
-    def __init__(self, device: str, dtype):
+    def __init__(self, device: str):
         self.device = device
-        self.dtype = dtype
-        self.models = {}
-        self.processors = {}
-        self.clip_model = None
-        self.clip_processor = None
-        self.food_labels = get_optimized_food101_labels()
-        self.label_list = list(self.food_labels.keys())
-        
-        # Load modeli
-        self._load_models()
+        logger.info(f"🚀 Loading CLIP model: {CLIP_MODEL_NAME}")
         
-    def _load_models(self):
-        """Učitava sve ensemble modele."""
-        logger.info("🚀 Učitavam ULTRA-OPTIMIZED ensemble modele...")
+        # Load CLIP model i processor
+        self.processor = CLIPProcessor.from_pretrained(CLIP_MODEL_NAME)
+        self.model = CLIPModel.from_pretrained(CLIP_MODEL_NAME).to(device)
+        self.model.eval()
         
-        # 1. Primary food model
-        try:
-            logger.info(f"Loading primary model: {FOOD_MODELS['primary']}")
-            self.processors["primary"] = AutoImageProcessor.from_pretrained(FOOD_MODELS["primary"])
-            self.models["primary"] = AutoModelForImageClassification.from_pretrained(
-                FOOD_MODELS["primary"], 
-                torch_dtype=self.dtype
-            ).to(self.device)
-            self.models["primary"].eval()
-            logger.info("✅ Primary model loaded successfully!")
-        except Exception as e:
-            logger.warning(f"⚠️ Primary model failed to load: {e}")
-            
-        # 2. Secondary food model
-        try:
-            logger.info(f"Loading secondary model: {FOOD_MODELS['secondary']}")
-            self.models["secondary"] = hf_pipeline(
-                "image-classification",
-                model=FOOD_MODELS["secondary"],
-                device=0 if self.device in ("cuda", "mps") else -1,
-                torch_dtype=self.dtype
-            )
-            logger.info("✅ Secondary model loaded successfully!")
-        except Exception as e:
-            logger.warning(f"⚠️ Secondary model failed to load: {e}")
-            
-        # 3. CLIP za non-food detection i fallback
-        try:
-            logger.info(f"Loading CLIP model: {CLIP_MODEL_NAME}")
-            self.clip_processor = CLIPProcessor.from_pretrained(CLIP_MODEL_NAME)
-            self.clip_model = CLIPModel.from_pretrained(
-                CLIP_MODEL_NAME, 
-                torch_dtype=self.dtype
-            ).to(self.device)
-            self.clip_model.eval()
-            logger.info("✅ CLIP model loaded successfully!")
-        except Exception as e:
-            logger.warning(f"⚠️ CLIP model failed to load: {e}")
-            
-        # Precompute CLIP text embeddings za food labele
-        if self.clip_model and self.clip_processor:
-            self._precompute_clip_embeddings()
-            
-    def _precompute_clip_embeddings(self):
-        """Precompute CLIP text embeddings za sve food labele."""
-        logger.info("🔄 Precomputing CLIP text embeddings...")
+        logger.info("✅ CLIP model loaded successfully!")
+    
+    def classify_food(self, image: Image.Image, custom_categories: List[str] = None) -> Dict[str, Any]:
+        """
+        Klasifikuje hranu na slici koristeći zero-shot CLIP pristup.
         
-        # Generiši text prompts za sve labele
-        text_prompts = []
-        for label, synonyms in self.food_labels.items():
-            # Dodaj glavni label
-            text_prompts.append(f"a photo of {label}")
-            # Dodaj sinonime
-            for synonym in synonyms[:2]:  # Uzmi prva 2 sinonima
-                text_prompts.append(f"a photo of {synonym}")
-                
-        # Compute embeddings
-        with torch.no_grad():
-            text_inputs = self.clip_processor(
-                text=text_prompts, 
-                return_tensors="pt", 
-                padding=True, 
-                truncation=True
-            )
-            text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
-            
-            with autocast_context(self.device, self.dtype):
-                self.text_embeddings = self.clip_model.get_text_features(**text_inputs)
-                self.text_embeddings = self.text_embeddings / self.text_embeddings.norm(dim=-1, keepdim=True)
-                
-        self.text_prompts = text_prompts
-        logger.info("✅ CLIP embeddings precomputed!")
+        Args:
+            image: PIL slika za analizu
+            custom_categories: Opcione custom kategorije (ako nisu date, koristi Food-101)
         
-    def detect_non_food(self, image: Image.Image) -> Tuple[bool, float]:
-        """
-        Detektuje da li slika sadrži non-food objekte koristeći CLIP.
-        Vraća (is_non_food, confidence).
+        Returns:
+            Dictionary sa rezultatima klasifikacije
         """
-        if not self.clip_model or not self.clip_processor:
-            return False, 0.0
-            
-        # Non-food prompts
-        non_food_prompts = [
-            "a photo of a bottle",
-            "a photo of water",
-            "a photo of a drink",
-            "a photo of a person",
-            "a photo of hands",
-            "a photo of a plate",
-            "a photo of a table",
-            "a photo of utensils",
-            "a photo of a background",
-            "a photo of furniture",
-            "a photo of electronics"
-        ]
+        # Koristi custom kategorije ili default food categories
+        categories = custom_categories if custom_categories else FOOD_CATEGORIES
         
-        # Food prompts
-        food_prompts = [
-            "a photo of food",
-            "a photo of a meal",
-            "a photo of something edible",
-            "a photo of cuisine",
-            "a photo of a dish"
-        ]
+        # Generiši text prompts za svaku kategoriju
+        text_prompts = [f"a photo of {category}" for category in categories]
         
-        all_prompts = non_food_prompts + food_prompts
+        logger.info(f"🔍 Analyzing image with {len(categories)} categories...")
         
-        try:
-            with torch.no_grad():
-                # Process image
-                image_inputs = self.clip_processor(images=image, return_tensors="pt")
-                image_inputs = {k: v.to(self.device) for k, v in image_inputs.items()}
-                
-                # Process text
-                text_inputs = self.clip_processor(text=all_prompts, return_tensors="pt", padding=True)
-                text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
-                
-                with autocast_context(self.device, self.dtype):
-                    # Get features
-                    image_features = self.clip_model.get_image_features(**image_inputs)
-                    text_features = self.clip_model.get_text_features(**text_inputs)
-                    
-                    # Normalize
-                    image_features = image_features / image_features.norm(dim=-1, keepdim=True)
-                    text_features = text_features / text_features.norm(dim=-1, keepdim=True)
-                    
-                    # Compute similarities
-                    similarities = (image_features @ text_features.t()).cpu().numpy()[0]
-                    
-                    # Split similarities
-                    non_food_sims = similarities[:len(non_food_prompts)]
-                    food_sims = similarities[len(non_food_prompts):]
-                    
-                    # Calculate scores
-                    max_non_food = np.max(non_food_sims)
-                    max_food = np.max(food_sims)
-                    
-                    # Decision logic
-                    is_non_food = max_non_food > max_food and max_non_food > 0.25
-                    confidence = max_non_food if is_non_food else max_food
-                    
-                    return is_non_food, float(confidence)
-                    
-        except Exception as e:
-            logger.warning(f"Non-food detection failed: {e}")
-            return False, 0.0
-    
-    def classify_with_primary(self, image: Image.Image) -> Dict[str, Any]:
-        """Klasifikacija sa primary modelom."""
-        if "primary" not in self.models:
-            return None
+        # Process inputs
+        with torch.no_grad():
+            inputs = self.processor(
+                text=text_prompts,
+                images=image,
+                return_tensors="pt",
+                padding=True
+            )
             
-        try:
-            inputs = self.processors["primary"](images=image, return_tensors="pt")
+            # Move to device
             inputs = {k: v.to(self.device) for k, v in inputs.items()}
             
-            with torch.no_grad(), autocast_context(self.device, self.dtype):
-                outputs = self.models["primary"](**inputs)
-                probs = F.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
-                
-            # Get top 5
-            top_indices = probs.argsort()[-5:][::-1]
-            labels = [self.models["primary"].config.id2label[i] for i in top_indices]
-            scores = [float(probs[i]) for i in top_indices]
-            
-            return {
-                "primary_label": labels[0],
-                "alternatives": labels[1:],
-                "confidence": scores[0],
-                "top5": list(zip(labels, scores)),
-                "model": "primary"
-            }
-            
-        except Exception as e:
-            logger.warning(f"Primary model classification failed: {e}")
-            return None
-    
-    def classify_with_secondary(self, image: Image.Image) -> Dict[str, Any]:
-        """Klasifikacija sa secondary modelom."""
-        if "secondary" not in self.models:
-            return None
-            
-        try:
-            results = self.models["secondary"](image)
-            
-            if not results:
-                return None
-                
-            labels = [r["label"] for r in results]
-            scores = [r["score"] for r in results]
+            # Get predictions
+            outputs = self.model(**inputs)
             
-            return {
-                "primary_label": labels[0],
-                "alternatives": labels[1:],
-                "confidence": scores[0],
-                "top5": list(zip(labels, scores)),
-                "model": "secondary"
-            }
-            
-        except Exception as e:
-            logger.warning(f"Secondary model classification failed: {e}")
-            return None
-    
-    def classify_with_clip(self, image: Image.Image) -> Dict[str, Any]:
-        """Klasifikacija sa CLIP modelom."""
-        if not self.clip_model or not self.clip_processor:
-            return None
-            
-        try:
-            with torch.no_grad():
-                # Process image
-                image_inputs = self.clip_processor(images=image, return_tensors="pt")
-                image_inputs = {k: v.to(self.device) for k, v in image_inputs.items()}
-                
-                with autocast_context(self.device, self.dtype):
-                    image_features = self.clip_model.get_image_features(**image_inputs)
-                    image_features = image_features / image_features.norm(dim=-1, keepdim=True)
-                    
-                    # Compute similarities sa precomputed embeddings
-                    similarities = (image_features @ self.text_embeddings.t()).cpu().numpy()[0]
-                    
-                    # Group by main labels
-                    label_scores = {}
-                    prompt_idx = 0
-                    
-                    for label, synonyms in self.food_labels.items():
-                        scores = []
-                        # Main label score
-                        scores.append(similarities[prompt_idx])
-                        prompt_idx += 1
-                        
-                        # Synonym scores
-                        for _ in synonyms[:2]:
-                            scores.append(similarities[prompt_idx])
-                            prompt_idx += 1
-                            
-                        # Take max score for this label
-                        label_scores[label] = max(scores)
-                    
-                    # Sort by score
-                    sorted_labels = sorted(label_scores.items(), key=lambda x: x[1], reverse=True)
-                    
-                    labels = [item[0] for item in sorted_labels[:5]]
-                    scores = [float(item[1]) for item in sorted_labels[:5]]
-                    
-                    return {
-                        "primary_label": labels[0],
-                        "alternatives": labels[1:],
-                        "confidence": scores[0],
-                        "top5": list(zip(labels, scores)),
-                        "model": "clip"
-                    }
-                    
-        except Exception as e:
-            logger.warning(f"CLIP classification failed: {e}")
-            return None
-    
-    def ensemble_classify(self, image: Image.Image) -> Dict[str, Any]:
-        """
-        Glavna ensemble klasifikacija koja kombinuje sve modele.
-        """
-        logger.info("🔍 Starting ULTRA ensemble classification...")
-        
-        # 1. Non-food detection
-        is_non_food, non_food_conf = self.detect_non_food(image)
-        if is_non_food and non_food_conf > 0.4:
-            logger.info(f"🚫 Non-food object detected (confidence: {non_food_conf:.3f})")
-            return {
-                "primary_label": "Non-food object",
-                "alternatives": [],
-                "confidence": non_food_conf,
-                "top5": [("Non-food object", non_food_conf)],
-                "model": "non_food_detector",
-                "is_food": False
-            }
-        
-        # 2. Preprocess image variants
-        image_variants = advanced_image_preprocessing(image)
-        
-        # 3. Collect predictions from all models
-        all_predictions = []
-        
-        for variant_idx, img_variant in enumerate(image_variants):
-            # Primary model
-            pred = self.classify_with_primary(img_variant)
-            if pred and pred["confidence"] > MIN_CONFIDENCE_THRESHOLD:
-                pred["variant"] = variant_idx
-                all_predictions.append(pred)
-            
-            # Secondary model (samo za prvu varijantu da uštedimo vreme)
-            if variant_idx == 0:
-                pred = self.classify_with_secondary(img_variant)
-                if pred and pred["confidence"] > MIN_CONFIDENCE_THRESHOLD:
-                    pred["variant"] = variant_idx
-                    all_predictions.append(pred)
-            
-            # CLIP model
-            pred = self.classify_with_clip(img_variant)
-            if pred and pred["confidence"] > MIN_CONFIDENCE_THRESHOLD:
-                pred["variant"] = variant_idx
-                all_predictions.append(pred)
+            # Calculate similarity scores
+            logits_per_image = outputs.logits_per_image
+            probs = logits_per_image.softmax(dim=1).cpu().numpy()[0]
+        
+        # Sort by probability
+        sorted_indices = probs.argsort()[::-1]
+        
+        # Get top 5 results
+        top5_results = []
+        for idx in sorted_indices[:5]:
+            category = categories[idx]
+            confidence = float(probs[idx])
+            top5_results.append({
+                "label": category,
+                "confidence": confidence
+            })
         
-        if not all_predictions:
-            logger.warning("⚠️ No valid predictions from any model")
-            return {
-                "primary_label": "Unknown food",
-                "alternatives": [],
-                "confidence": 0.0,
-                "top5": [],
-                "model": "ensemble",
-                "is_food": True
-            }
+        # Best result
+        best_label = categories[sorted_indices[0]]
+        best_confidence = float(probs[sorted_indices[0]])
         
-        # 4. Ensemble voting
-        final_result = self._ensemble_vote(all_predictions)
-        final_result["is_food"] = True
+        logger.info(f"✅ Best match: {best_label} ({best_confidence:.2%})")
         
-        logger.info(f"✅ Ensemble result: {final_result['primary_label']} (confidence: {final_result['confidence']:.3f})")
-        return final_result
+        return {
+            "primary_label": best_label,
+            "confidence": best_confidence,
+            "top5": top5_results,
+            "alternatives": [r["label"] for r in top5_results[1:4]]
+        }
     
-    def _ensemble_vote(self, predictions: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """
-        Implementira sofisticiran ensemble voting algoritam.
+    def detect_if_food(self, image: Image.Image) -> tuple[bool, float]:
         """
-        if not predictions:
-            return {
-                "primary_label": "Unknown",
-                "alternatives": [],
-                "confidence": 0.0,
-                "top5": [],
-                "model": "ensemble"
-            }
-        
-        # Ako imamo samo jednu predikciju
-        if len(predictions) == 1:
-            result = predictions[0].copy()
-            result["model"] = "ensemble"
-            return result
-        
-        # Weighted voting based on model confidence and type
-        model_weights = {
-            "primary": 1.5,    # Specijalizovani food model ima najveću težinu
-            "secondary": 1.2,  # Backup food model
-            "clip": 1.0        # CLIP kao fallback
-        }
-        
-        # Collect all labels with weighted scores
-        label_scores = {}
-        
-        for pred in predictions:
-            model_type = pred["model"]
-            weight = model_weights.get(model_type, 1.0)
-            
-            # Main label
-            main_label = pred["primary_label"]
-            confidence = pred["confidence"]
-            weighted_score = confidence * weight
-            
-            if main_label in label_scores:
-                label_scores[main_label] += weighted_score
-            else:
-                label_scores[main_label] = weighted_score
-            
-            # Alternative labels (sa manjom težinom)
-            for alt_label in pred["alternatives"][:2]:  # Top 2 alternative
-                alt_weight = weight * 0.3
-                if alt_label in label_scores:
-                    label_scores[alt_label] += alt_weight
-                else:
-                    label_scores[alt_label] = alt_weight
-        
-        # Sort by weighted score
-        sorted_labels = sorted(label_scores.items(), key=lambda x: x[1], reverse=True)
+        Detektuje da li slika sadrži hranu.
         
-        # Normalize scores
-        max_score = sorted_labels[0][1] if sorted_labels else 1.0
-        normalized_scores = [(label, score/max_score) for label, score in sorted_labels]
+        Returns:
+            (is_food, confidence) tuple
+        """
+        categories = ["food", "non-food object"]
+        text_prompts = [f"a photo of {cat}" for cat in categories]
         
-        # Extract top results
-        top_labels = [item[0] for item in normalized_scores[:5]]
-        top_scores = [item[1] for item in normalized_scores[:5]]
+        with torch.no_grad():
+            inputs = self.processor(
+                text=text_prompts,
+                images=image,
+                return_tensors="pt",
+                padding=True
+            )
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            outputs = self.model(**inputs)
+            probs = outputs.logits_per_image.softmax(dim=1).cpu().numpy()[0]
         
-        # Check for high agreement
-        if len(predictions) >= 2 and top_scores[0] > ENSEMBLE_AGREEMENT_THRESHOLD:
-            confidence_boost = 1.1  # Boost confidence if models agree
-        else:
-            confidence_boost = 1.0
-            
-        final_confidence = min(top_scores[0] * confidence_boost, 1.0)
+        is_food = probs[0] > probs[1]
+        confidence = float(probs[0] if is_food else probs[1])
         
-        return {
-            "primary_label": top_labels[0],
-            "alternatives": top_labels[1:4],
-            "confidence": final_confidence,
-            "top5": list(zip(top_labels, top_scores)),
-            "model": "ensemble",
-            "num_models": len(predictions)
-        }
+        return is_food, confidence
 
-# --- Nutrition Functions (unchanged from original) ---
-def clean_food_name(food_name: str) -> str:
-    """Čisti naziv hrane za nutrition pretragu."""
-    name = food_name.lower().strip()
-    remove_words = [
-        'a', 'an', 'the', 'with', 'and', 'or', 'of', 'in', 'on',
-        'some', 'various', 'different', 'multiple', 'several'
-    ]
-    words = name.split()
-    words = [w for w in words if w not in remove_words]
-    return ' '.join(words) if words else food_name
 
-def search_nutrition_data(food_name: str, alternatives: List[str] = None) -> Optional[Dict[str, Any]]:
+def search_nutrition_data(food_name: str) -> Optional[Dict[str, Any]]:
     """Pretražuje nutritivne podatke preko Open Food Facts API-ja."""
-    search_terms = [food_name]
-    if alternatives:
-        search_terms.extend(alternatives[:3])
-    
-    for term in search_terms:
-        try:
-            clean_term = clean_food_name(term)
-            logger.info(f"🔍 Tražim nutritivne podatke za: '{clean_term}'")
-            
-            search_url = "https://world.openfoodfacts.org/cgi/search.pl"
-            params = {
-                "search_terms": clean_term,
-                "search_simple": 1,
-                "action": "process",
-                "json": 1,
-                "page_size": 5
-            }
-            
-            response = requests.get(search_url, params=params, timeout=5)
+    try:
+        logger.info(f"🔍 Searching nutrition data for: '{food_name}'")
+        
+        search_url = "https://world.openfoodfacts.org/cgi/search.pl"
+        params = {
+            "search_terms": food_name,
+            "search_simple": 1,
+            "action": "process",
+            "json": 1,
+            "page_size": 5
+        }
+        
+        response = requests.get(search_url, params=params, timeout=5)
+        
+        if response.status_code == 200:
+            data = response.json()
             
-            if response.status_code == 200:
-                data = response.json()
-                
-                if data.get('products') and len(data['products']) > 0:
-                    for product in data['products']:
-                        nutriments = product.get('nutriments', {})
+            if data.get('products') and len(data['products']) > 0:
+                for product in data['products']:
+                    nutriments = product.get('nutriments', {})
+                    
+                    if all(key in nutriments for key in ['energy-kcal_100g', 'proteins_100g', 'carbohydrates_100g', 'fat_100g']):
+                        logger.info(f"✅ Found nutrition data")
                         
-                        if all(key in nutriments for key in ['energy-kcal_100g', 'proteins_100g', 'carbohydrates_100g', 'fat_100g']):
-                            logger.info(f"✅ Pronađeni nutritivni podaci za '{product.get('product_name', term)}'")
-                            
-                            return {
-                                "name": product.get('product_name', term),
-                                "brand": product.get('brands', 'Unknown'),
-                                "nutrition": {
-                                    "calories": nutriments.get('energy-kcal_100g', 0),
-                                    "protein": nutriments.get('proteins_100g', 0),
-                                    "carbs": nutriments.get('carbohydrates_100g', 0),
-                                    "fat": nutriments.get('fat_100g', 0),
-                                    "fiber": nutriments.get('fiber_100g'),
-                                    "sugar": nutriments.get('sugars_100g'),
-                                    "sodium": nutriments.get('sodium_100g', 0) * 1000 if nutriments.get('sodium_100g') else None
-                                },
-                                "source": "Open Food Facts",
-                                "serving_size": 100,
-                                "serving_unit": "g"
-                            }
-            
-        except Exception as e:
-            logger.warning(f"⚠️ Greška pri pretraživanju '{term}': {e}")
-            continue
+                        return {
+                            "name": product.get('product_name', food_name),
+                            "brand": product.get('brands', 'Unknown'),
+                            "nutrition": {
+                                "calories": nutriments.get('energy-kcal_100g', 0),
+                                "protein": nutriments.get('proteins_100g', 0),
+                                "carbs": nutriments.get('carbohydrates_100g', 0),
+                                "fat": nutriments.get('fat_100g', 0),
+                                "fiber": nutriments.get('fiber_100g'),
+                                "sugar": nutriments.get('sugars_100g'),
+                                "sodium": nutriments.get('sodium_100g', 0) * 1000 if nutriments.get('sodium_100g') else None
+                            },
+                            "source": "Open Food Facts",
+                            "serving_size": 100,
+                            "serving_unit": "g"
+                        }
+        
+    except Exception as e:
+        logger.warning(f"⚠️ Nutrition search error: {e}")
     
-    logger.warning(f"⚠️ Nisu pronađeni podaci, koristim procjenu za: '{food_name}'")
     return get_estimated_nutrition(food_name)
 
+
 def get_estimated_nutrition(food_name: str) -> Dict[str, Any]:
-    """Vraća procijenjene nutritivne vrijednosti na osnovu kategorije hrane."""
+    """Vraća procijenjene nutritivne vrijednosti."""
     food_lower = food_name.lower()
     
     categories = {
@@ -776,19 +251,17 @@ def get_estimated_nutrition(food_name: str) -> Dict[str, Any]:
         'dairy': {'calories': 60, 'protein': 3.5, 'carbs': 5, 'fat': 3, 'fiber': 0, 'sugar': 5, 'sodium': 50},
         'dessert': {'calories': 350, 'protein': 4, 'carbs': 50, 'fat': 15, 'fiber': 1, 'sugar': 40, 'sodium': 200},
         'fast_food': {'calories': 250, 'protein': 12, 'carbs': 30, 'fat': 10, 'fiber': 2, 'sugar': 5, 'sodium': 600},
-        'bread': {'calories': 265, 'protein': 9, 'carbs': 49, 'fat': 3.2, 'fiber': 2.7, 'sugar': 5, 'sodium': 500},
     }
     
     category_keywords = {
-        'fruit': ['apple', 'banana', 'orange', 'berry', 'fruit', 'grape', 'melon', 'peach', 'pear'],
-        'vegetable': ['salad', 'lettuce', 'tomato', 'cucumber', 'carrot', 'broccoli', 'vegetable'],
-        'meat': ['chicken', 'beef', 'pork', 'steak', 'meat', 'ribs'],
-        'fish': ['fish', 'salmon', 'tuna', 'seafood', 'crab', 'lobster', 'shrimp'],
-        'grain': ['rice', 'pasta', 'noodle', 'bread', 'grain'],
-        'dairy': ['milk', 'cheese', 'yogurt', 'dairy'],
-        'dessert': ['cake', 'cookie', 'chocolate', 'ice cream', 'dessert', 'pie', 'mousse'],
-        'fast_food': ['burger', 'pizza', 'fries', 'sandwich'],
-        'bread': ['bread', 'roll', 'bun', 'toast']
+        'fruit': ['apple', 'banana', 'orange', 'berry', 'fruit'],
+        'vegetable': ['salad', 'vegetable', 'tomato'],
+        'meat': ['chicken', 'beef', 'pork', 'steak', 'meat'],
+        'fish': ['fish', 'salmon', 'tuna', 'seafood'],
+        'grain': ['rice', 'pasta', 'noodle', 'bread'],
+        'dairy': ['cheese', 'yogurt', 'milk'],
+        'dessert': ['cake', 'cookie', 'chocolate', 'ice cream'],
+        'fast_food': ['burger', 'pizza', 'fries'],
     }
     
     detected_category = 'grain'
@@ -806,60 +279,50 @@ def get_estimated_nutrition(food_name: str) -> Dict[str, Any]:
         "source": "AI Estimation",
         "serving_size": 100,
         "serving_unit": "g",
-        "note": "Nutritivne vrijednosti su procijenjene na osnovu kategorije hrane"
+        "note": "Estimated values based on food category"
     }
 
+
 def is_image_file(file: UploadFile):
-    """Provjerava da li je fajl podržani format slike."""
+    """Provjerava da li je fajl slika."""
     return file.content_type in ["image/jpeg", "image/png", "image/jpg", "image/webp"]
 
-# --- Initialize Ultra Classifier ---
-logger.info("🚀 Initializing ULTRA-OPTIMIZED Food Scanner API v10.0...")
+
+# --- Initialize Classifier ---
+logger.info("🚀 Initializing Zero-Shot Food Recognition API...")
 device = select_device()
-dtype = select_dtype(device)
-logger.info(f"Using device: {device} | dtype: {dtype}")
+logger.info(f"Using device: {device}")
 
-# Initialize ultra classifier
-ultra_classifier = UltraFoodClassifier(device, dtype)
+classifier = ZeroShotFoodClassifier(device)
 
 # --- FastAPI Application ---
 app = FastAPI(
-    title="🏆 ULTRA-OPTIMIZED Food Scanner API v10.0 - 99% Accuracy Edition",
+    title="🎯 Zero-Shot Food Recognition API - CLIP Edition",
     description="""
-    **🎯 ULTRA-PRECIZNO prepoznavanje hrane sa 99% tačnošću**
-    
-    Revolucionarni food recognition sistem sa ensemble pristupom i specijalizovanim modelima.
-    
-    ### 🌟 ULTRA Mogućnosti:
-    - 🎯 **99% Preciznost** - Ensemble od 3+ specijalizovana modela
-    - 🚫 **Non-food Detection** - Automatski odbacuje non-food objekte
-    - 🔄 **Smart Preprocessing** - 5 varijanti slike za maksimalnu preciznost
-    - 📊 **Confidence Filtering** - Samo visoko-pouzdani rezultati
-    - 🧠 **Intelligent Voting** - Sofisticiran ensemble algoritam
-    - 🏷️ **Optimizovane Labele** - Food-101 sa sinonimima i varijantama
-    - ⚡ **Ultra-brza Inferenca** - Optimizovano za production
-    - 📊 **Realni Nutrition Podaci** - Open Food Facts integracija
-    
-    ### 🎯 Kako ULTRA Radi:
-    1. **Non-food Check** - Prvo proverava da li je objekat hrana
-    2. **Multi-variant Processing** - Generiše 5 optimizovanih varijanti slike
-    3. **Ensemble Classification** - 3+ modela analizira svaku varijantu
-    4. **Smart Voting** - Napredni algoritam kombinuje rezultate
-    5. **Confidence Filtering** - Odbacuje nesigurne rezultate
-    6. **Nutrition Lookup** - Automatski pronalazi nutritivne podatke
-    
-    ### 🏆 ULTRA Prednosti:
-    - 🎯 **99% Accuracy** - Nikad više pogrešnih rezultata
-    - 🚫 **Zero False Positives** - Non-food objekti se automatski odbacuju
-    - ⚡ **Production Ready** - Optimizovano za real-world usage
-    - 🔒 **Self-hosted** - Potpuna kontrola i privatnost
-    - 💰 **100% Free** - Bez API troškova
-    - 🌍 **Offline Capable** - Radi bez interneta (osim nutrition lookup)
+    **Jednostavan i moćan food recognition sistem sa CLIP modelom**
+    
+    ### 🌟 Ključne mogućnosti:
+    - 🌍 **Zero-shot Learning** - Prepoznaje bilo šta bez dodatnog treninga
+    - 🎯 **Veliki spektar** - Ne samo hrana, već bilo koji objekat
+    - 🚀 **Jednostavan** - Clean i razumljiv kod
+    - 📊 **Pouzdan** - CLIP model sa state-of-the-art performansama
+    - 🏷️ **Fleksibilan** - Customizabilne kategorije
+    - ⚡ **Brz** - Optimizovana inferenca
+    
+    ### 📖 Kako CLIP radi:
+    CLIP je vision-language model koji razume vezu između slika i teksta.
+    Može prepoznati bilo koji objekat - samo mu kažeš šta da traži!
+    
+    ### 🎯 Primjena:
+    - Food recognition i nutrition tracking
+    - Općenita object detection
+    - Visual search
+    - Image classification za bilo koju domenu
     """,
-    version="10.0.0 - ULTRA OPTIMIZED"
+    version="11.0.0"
 )
 
-# CORS middleware
+# CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -868,404 +331,281 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+
 @app.post("/analyze", 
-    summary="🎯 ULTRA Food Analysis",
-    description="Upload sliku za ULTRA-precizno prepoznavanje hrane sa 99% tačnošću",
-    response_description="ULTRA-precizni rezultati food recognition i nutritivnih podataka"
+    summary="🎯 Analyze Food Image",
+    description="Upload sliku za zero-shot food recognition"
 )
 async def analyze(file: UploadFile = File(...)):
     """
-    **🏆 ULTRA Food Analysis Endpoint - 99% Accuracy**
+    Analizira sliku i prepoznaje hranu koristeći CLIP zero-shot pristup.
     
-    Revolucionarni endpoint koji garantuje maksimalnu preciznost u prepoznavanju hrane.
-    
-    ### 🎯 ULTRA Features:
-    - Ensemble od 3+ specijalizovana modela
-    - Non-food detection
-    - Multi-variant image processing
-    - Smart confidence filtering
-    - Intelligent voting algoritam
-    - Automatski nutrition lookup
+    Model automatski prepoznaje hranu iz Food-101 kategorija bez potrebe
+    za dodatnim treningom.
     """
     if not file:
-        raise HTTPException(status_code=400, detail="Slika nije poslata.")
+        raise HTTPException(status_code=400, detail="No image provided")
 
     if not is_image_file(file):
-        raise HTTPException(
-            status_code=400, 
-            detail="Nepodržan format slike. Koristi JPEG, PNG ili WebP."
-        )
+        raise HTTPException(status_code=400, detail="Unsupported image format. Use JPEG, PNG or WebP.")
 
     try:
+        # Load image
         contents = await file.read()
         image = Image.open(BytesIO(contents))
         
-        # Konvertuj u RGB ako je potrebno
         if image.mode != "RGB":
             image = image.convert("RGB")
         
-        # Sačuvaj dimenzije slike
         image_width, image_height = image.size
+        
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Greška pri čitanju slike: {e}")
+        raise HTTPException(status_code=500, detail=f"Error reading image: {e}")
 
     try:
-        # ULTRA ensemble classification
-        logger.info("🎯 Starting ULTRA food analysis...")
-        classification = ultra_classifier.ensemble_classify(image)
+        # Check if it's food
+        is_food, food_confidence = classifier.detect_if_food(image)
         
-        # Check if it's non-food
-        if not classification.get("is_food", True):
+        if not is_food and food_confidence > 0.6:
             return JSONResponse(content={
                 "success": False,
                 "error": "Non-food object detected",
-                "message": "Slika ne sadrži hranu. Molim upload-uj sliku hrane.",
-                "detected_object": classification["primary_label"],
-                "confidence": classification["confidence"],
-                "model_info": {
-                    "type": "ULTRA Non-food Detector",
-                    "version": "10.0.0"
-                }
+                "message": "Image doesn't contain food. Please upload a food image.",
+                "confidence": food_confidence
             })
         
-        # Check confidence threshold
-        if classification["confidence"] < MIN_CONFIDENCE_THRESHOLD:
+        # Classify food
+        logger.info("🔍 Classifying food...")
+        result = classifier.classify_food(image)
+        
+        if result["confidence"] < MIN_CONFIDENCE:
             raise HTTPException(
                 status_code=422,
-                detail=f"Niska sigurnost prepoznavanja ({classification['confidence']:.2f}). Molim upload-uj jasniju sliku hrane."
+                detail=f"Low confidence ({result['confidence']:.2%}). Please upload a clearer image."
             )
-            
+        
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"ULTRA classification error: {e}")
-        raise HTTPException(status_code=500, detail=f"Greška tokom ULTRA analize: {e}")
+        logger.error(f"Classification error: {e}")
+        raise HTTPException(status_code=500, detail=f"Classification error: {e}")
 
     # Get nutrition data
-    logger.info(f"🍎 ULTRA prepoznata hrana: {classification['primary_label']}")
-    nutrition_data = search_nutrition_data(
-        classification["primary_label"], 
-        alternatives=classification["alternatives"]
-    )
+    logger.info(f"🍎 Recognized food: {result['primary_label']}")
+    nutrition_data = search_nutrition_data(result["primary_label"])
     
-    # Prepare ULTRA response
-    final_response = {
+    # Prepare response
+    response = {
         "success": True,
-        "label": classification["primary_label"],
-        "confidence": classification["confidence"],
-        "is_food": True,
+        "label": result["primary_label"],
+        "confidence": result["confidence"],
+        "alternatives": result["alternatives"],
         
-        # Nutrition data
+        # Nutrition
         "nutrition": nutrition_data["nutrition"],
         "source": nutrition_data["source"],
         
-        # Alternatives
-        "alternatives": classification["alternatives"],
-        
-        # ULTRA AI analysis
-        "ai_analysis": {
-            "detailed_description": f"ULTRA ensemble analysis: {classification['primary_label']} detected with {classification['confidence']:.1%} confidence using {classification.get('num_models', 1)} specialized models.",
-            "food_items": f"1) {classification['primary_label']}",
-            "confidence_level": "High" if classification["confidence"] > HIGH_CONFIDENCE_THRESHOLD else "Medium",
-            "model_agreement": f"{classification.get('num_models', 1)} models participated in ensemble voting"
-        },
-        
+        # Image info
         "image_info": {
             "width": image_width,
             "height": image_height,
             "format": image.format
         },
         
+        # Model info
         "model_info": {
-            "type": "ULTRA-OPTIMIZED Ensemble Food Classifier",
-            "version": "10.0.0",
-            "models_used": classification.get("num_models", 1),
-            "ensemble_method": "Weighted Voting with Confidence Filtering",
-            "accuracy": "99%+",
-            "specialization": "Food-only Recognition",
-            "features": [
-                "Multi-model Ensemble",
-                "Non-food Detection", 
-                "Advanced Preprocessing",
-                "Confidence Filtering",
-                "Smart Voting Algorithm"
-            ]
+            "type": "Zero-Shot CLIP Classifier",
+            "model": CLIP_MODEL_NAME,
+            "version": "11.0.0",
+            "method": "Zero-shot learning",
+            "categories": len(FOOD_CATEGORIES),
+            "device": device
         }
     }
 
-    return JSONResponse(content=final_response)
+    return JSONResponse(content=response)
+
 
-@app.get("/search-nutrition/{food_name}",
-    summary="🔍 Nutrition Lookup",
-    description="Pretraži nutritivne podatke za specifičnu hranu po imenu"
+@app.post("/analyze-custom",
+    summary="🎯 Analyze with Custom Categories",
+    description="Upload sliku i definiši custom kategorije za prepoznavanje"
 )
-async def search_nutrition(food_name: str):
-    """Nutrition lookup endpoint (unchanged)."""
+async def analyze_custom(
+    file: UploadFile = File(...),
+    categories: str = None
+):
+    """
+    Zero-shot analiza sa custom kategorijama.
+    
+    Primjer: categories="pizza,burger,pasta,salad"
+    
+    Ovo demonstrira moć CLIP-a - može prepoznati bilo šta što mu kažeš!
+    """
+    if not file:
+        raise HTTPException(status_code=400, detail="No image provided")
+
+    if not is_image_file(file):
+        raise HTTPException(status_code=400, detail="Unsupported image format")
+    
+    # Parse categories
+    custom_categories = None
+    if categories:
+        custom_categories = [cat.strip() for cat in categories.split(",")]
+        logger.info(f"Using custom categories: {custom_categories}")
+
     try:
-        logger.info(f"🔍 Manual pretraga nutritivnih podataka za: '{food_name}'")
+        contents = await file.read()
+        image = Image.open(BytesIO(contents))
         
-        nutrition_data = search_nutrition_data(food_name)
+        if image.mode != "RGB":
+            image = image.convert("RGB")
         
-        if not nutrition_data:
-            raise HTTPException(
-                status_code=404,
-                detail=f"Nisam mogao pronaći nutritivne podatke za '{food_name}'"
-            )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading image: {e}")
+
+    try:
+        result = classifier.classify_food(image, custom_categories=custom_categories)
         
         return JSONResponse(content={
             "success": True,
-            "food_name": food_name,
-            "nutrition": nutrition_data["nutrition"],
-            "source": nutrition_data["source"],
-            "serving_size": nutrition_data["serving_size"],
-            "serving_unit": nutrition_data["serving_unit"],
-            "note": nutrition_data.get("note", "")
+            "label": result["primary_label"],
+            "confidence": result["confidence"],
+            "top5": result["top5"],
+            "categories_used": custom_categories if custom_categories else "Food-101 default",
+            "model_info": {
+                "type": "Zero-Shot CLIP Classifier",
+                "model": CLIP_MODEL_NAME,
+                "method": "Custom zero-shot classification"
+            }
         })
         
-    except HTTPException:
-        raise
     except Exception as e:
-        logger.error(f"Nutrition search error: {e}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Greška pri pretraživanju: {e}"
-        )
+        logger.error(f"Classification error: {e}")
+        raise HTTPException(status_code=500, detail=f"Classification error: {e}")
+
 
-@app.get("/", 
-    summary="🏆 ULTRA API Info",
-    description="Informacije o ULTRA-OPTIMIZED Food Scanner API-ju"
+@app.get("/",
+    summary="🎯 API Info",
+    description="Informacije o Zero-Shot Food Recognition API-ju"
 )
 def root():
-    """Root endpoint sa ULTRA API informacijama."""
+    """Root endpoint sa API informacijama."""
     return {
-        "message": "🏆 ULTRA-OPTIMIZED Food Scanner API v10.0 - 99% Accuracy Edition",
-        "status": "🟢 Online & ULTRA-Ready",
-        "tagline": "🎯 Najbolji Self-Hosted Food Recognition sa 99% Preciznosti",
+        "message": "🎯 Zero-Shot Food Recognition API - CLIP Edition",
+        "status": "🟢 Online & Ready",
+        "tagline": "Jednostavan i moćan food recognition sa zero-shot learning",
         "model": {
-            "type": "ULTRA Ensemble Food Classifier",
-            "version": "10.0.0",
-            "accuracy": "99%+",
-            "models": list(FOOD_MODELS.values()) + [CLIP_MODEL_NAME],
-            "ensemble_method": "Weighted Voting with Confidence Filtering",
+            "name": CLIP_MODEL_NAME,
+            "type": "Vision-Language Model (CLIP)",
+            "capabilities": "Zero-shot classification",
             "device": device.upper(),
-            "specialization": "Food-only Recognition"
-        },
-        "ultra_features": {
-            "ensemble_models": "✅ 3+ Specialized Food Models",
-            "non_food_detection": "✅ Automatic Non-food Filtering",
-            "advanced_preprocessing": "✅ 5-variant Image Processing",
-            "confidence_filtering": "✅ Smart Threshold Management",
-            "intelligent_voting": "✅ Weighted Ensemble Algorithm",
-            "optimized_labels": "✅ Food-101 with Synonyms",
-            "nutrition_data": "✅ Real Nutritional Information",
-            "offline_capable": "✅ Works Without Internet (vision only)"
+            "food_categories": len(FOOD_CATEGORIES)
         },
-        "accuracy_guarantees": {
-            "food_recognition": "99%+ accuracy on clear food images",
-            "non_food_rejection": "Automatic detection and rejection",
-            "false_positives": "Near-zero with confidence filtering",
-            "edge_cases": "Handled by ensemble voting"
+        "features": {
+            "zero_shot": "✅ Prepoznaje bilo šta bez dodatnog treninga",
+            "customizable": "✅ Customizabilne kategorije",
+            "fast": "✅ Brza inferenca",
+            "simple": "✅ Jednostavan i čist kod",
+            "nutrition": "✅ Automatski nutrition lookup",
+            "open_source": "✅ 100% open-source"
         },
         "endpoints": {
-            "POST /analyze": "🎯 ULTRA food analysis with 99% accuracy",
-            "GET /search-nutrition/{food_name}": "🔍 Manual nutrition lookup",
-            "GET /health": "💚 System health check",
-            "GET /capabilities": "📋 Detailed capabilities info"
+            "POST /analyze": "🎯 Standard food analysis (Food-101 categories)",
+            "POST /analyze-custom": "🎨 Custom category analysis",
+            "GET /health": "💚 Health check",
+            "GET /categories": "📋 List all food categories"
         },
-        "ultra_advantages": [
-            "🎯 99% Accuracy - No more wrong predictions",
-            "🚫 Zero False Positives - Non-food objects rejected",
-            "⚡ Ultra-fast Inference - Optimized for production",
-            "🔒 Self-hosted - Complete privacy control",
-            "💰 100% Free - No API costs ever",
-            "🌍 Offline Ready - Works without internet",
-            "🏆 Production Proven - Battle-tested reliability"
-        ]
+        "about_clip": {
+            "what_is_clip": "CLIP (Contrastive Language-Image Pre-training) je model koji razume vezu između slika i teksta",
+            "zero_shot": "Može prepoznati bilo šta - samo mu kažeš šta da traži!",
+            "trained_on": "400+ miliona image-text parova sa interneta",
+            "advantages": [
+                "Prepoznaje širok spektar objekata",
+                "Nema potrebe za dodatnim treningom",
+                "Fleksibilan - radi sa bilo kojim kategorijama",
+                "State-of-the-art performanse"
+            ]
+        }
     }
 
-@app.get("/health", 
-    summary="💚 ULTRA Health Check",
-    description="Provjeri da li ULTRA API i svi modeli rade ispravno"
+
+@app.get("/health",
+    summary="💚 Health Check",
+    description="Provjeri status sistema"
 )
 def health_check():
-    """ULTRA health check endpoint."""
-    # Check model availability
-    models_loaded = {
-        "primary": "primary" in ultra_classifier.models,
-        "secondary": "secondary" in ultra_classifier.models,
-        "clip": ultra_classifier.clip_model is not None
-    }
-    
-    models_healthy = sum(models_loaded.values())
-    overall_health = "healthy" if models_healthy >= 2 else "degraded" if models_healthy >= 1 else "unhealthy"
-    
-    # Test nutrition API
-    nutrition_api_status = "unknown"
+    """Health check endpoint."""
     try:
-        test_response = requests.get("https://world.openfoodfacts.org/api/v0/product/737628064502.json", timeout=3)
-        nutrition_api_status = "healthy" if test_response.status_code == 200 else "degraded"
-    except:
-        nutrition_api_status = "offline"
-    
-    return {
-        "status": overall_health,
-        "version": "10.0.0 - ULTRA OPTIMIZED",
-        "type": "ULTRA Ensemble Food Classifier",
-        "device": device,
-        "models": {
-            "primary_food_model": {
-                "name": FOOD_MODELS["primary"],
-                "loaded": models_loaded["primary"],
-                "status": "healthy" if models_loaded["primary"] else "failed"
-            },
-            "secondary_food_model": {
-                "name": FOOD_MODELS["secondary"],
-                "loaded": models_loaded["secondary"],
-                "status": "healthy" if models_loaded["secondary"] else "failed"
-            },
-            "clip_model": {
+        model_loaded = classifier.model is not None
+        
+        # Test nutrition API
+        nutrition_api_status = "unknown"
+        try:
+            test_response = requests.get(
+                "https://world.openfoodfacts.org/api/v0/product/737628064502.json", 
+                timeout=3
+            )
+            nutrition_api_status = "healthy" if test_response.status_code == 200 else "degraded"
+        except:
+            nutrition_api_status = "offline"
+        
+        return {
+            "status": "healthy" if model_loaded else "unhealthy",
+            "version": "11.0.0 - ZERO-SHOT CLIP EDITION",
+            "model": {
                 "name": CLIP_MODEL_NAME,
-                "loaded": models_loaded["clip"],
-                "status": "healthy" if models_loaded["clip"] else "failed"
+                "loaded": model_loaded,
+                "device": device,
+                "type": "Zero-shot CLIP"
+            },
+            "nutrition_api": nutrition_api_status,
+            "capabilities": {
+                "food_recognition": model_loaded,
+                "zero_shot_classification": model_loaded,
+                "custom_categories": model_loaded,
+                "nutrition_lookup": nutrition_api_status in ["healthy", "degraded"]
             }
-        },
-        "ensemble_status": f"{models_healthy}/3 models loaded",
-        "nutrition_api": nutrition_api_status,
-        "accuracy_rating": "99%+" if models_healthy >= 2 else "Degraded",
-        "capabilities": {
-            "food_recognition": models_healthy >= 1,
-            "non_food_detection": models_loaded["clip"],
-            "ensemble_voting": models_healthy >= 2,
-            "nutrition_lookup": nutrition_api_status in ["healthy", "degraded"]
         }
-    }
+    except Exception as e:
+        return {
+            "status": "error",
+            "error": str(e)
+        }
+
 
-@app.get("/capabilities",
-    summary="📋 ULTRA Capabilities",
-    description="Detaljne informacije o ULTRA mogućnostima sistema"
+@app.get("/categories",
+    summary="📋 List Food Categories",
+    description="Lista svih dostupnih food kategorija"
 )
-def get_capabilities():
-    """Vraća detaljne ULTRA capabilities."""
+def get_categories():
+    """Vraća listu svih Food-101 kategorija."""
     return {
-        "system_type": "ULTRA-OPTIMIZED Food Recognition System",
-        "version": "10.0.0",
-        "accuracy_rating": "99%+",
-        "specialization": "Food-only Recognition with Ensemble Intelligence",
-        
-        "core_models": {
-            "primary": {
-                "name": FOOD_MODELS["primary"],
-                "type": "Specialized Food Classifier",
-                "weight": 1.5,
-                "purpose": "Primary food recognition"
-            },
-            "secondary": {
-                "name": FOOD_MODELS["secondary"],
-                "type": "Food Classification Pipeline",
-                "weight": 1.2,
-                "purpose": "Backup food recognition"
-            },
-            "clip": {
-                "name": CLIP_MODEL_NAME,
-                "type": "Vision-Language Model",
-                "weight": 1.0,
-                "purpose": "Non-food detection & fallback"
-            }
-        },
-        
-        "ultra_features": {
-            "ensemble_classification": {
-                "description": "Combines 3+ specialized models using weighted voting",
-                "method": "Confidence-weighted ensemble with agreement thresholds",
-                "accuracy_boost": "15-25% over single model"
-            },
-            "non_food_detection": {
-                "description": "Automatically detects and rejects non-food objects",
-                "method": "CLIP-based semantic understanding",
-                "false_positive_reduction": "95%+"
-            },
-            "advanced_preprocessing": {
-                "description": "Generates 5 optimized image variants for analysis",
-                "variants": ["Original", "Enhanced contrast", "Brightened", "Sharpened", "Center cropped"],
-                "accuracy_improvement": "10-15%"
-            },
-            "confidence_filtering": {
-                "description": "Rejects low-confidence predictions to ensure quality",
-                "min_threshold": MIN_CONFIDENCE_THRESHOLD,
-                "high_threshold": HIGH_CONFIDENCE_THRESHOLD,
-                "reliability": "99%+"
-            },
-            "optimized_labels": {
-                "description": "Food-101 labels enhanced with synonyms and variants",
-                "total_labels": len(get_optimized_food101_labels()),
-                "synonym_mapping": "2-3 synonyms per label",
-                "coverage": "Comprehensive food categories"
-            }
-        },
-        
-        "performance_metrics": {
-            "accuracy": "99%+ on clear food images",
-            "precision": "98%+ (very few false positives)",
-            "recall": "97%+ (catches most food items)",
-            "f1_score": "98%+",
-            "non_food_rejection": "95%+ accuracy",
-            "inference_time": "< 2 seconds per image"
-        },
-        
-        "use_cases": [
-            "🍽️ Professional nutrition tracking applications",
-            "📱 Consumer calorie counting apps",
-            "🏥 Medical dietary monitoring systems",
-            "🍕 Restaurant menu digitalization",
-            "🛒 Grocery shopping assistants",
-            "👨‍🍳 Recipe analysis and ingredient detection",
-            "📊 Food industry quality control",
-            "🎓 Educational food recognition tools",
-            "🔬 Research applications in food science",
-            "🌍 Agricultural product classification"
-        ],
-        
-        "technical_advantages": [
-            "🎯 Highest accuracy in food recognition",
-            "🚫 Eliminates false positives with non-food detection",
-            "⚡ Production-optimized for real-world usage",
-            "🔒 Complete privacy with self-hosting",
-            "💰 Zero ongoing costs (no API fees)",
-            "🌍 Works offline for vision tasks",
-            "🔄 Continuous improvement through ensemble learning",
-            "📊 Real nutritional data integration",
-            "🛡️ Robust error handling and fallbacks",
-            "⚙️ Highly configurable and extensible"
-        ]
+        "total": len(FOOD_CATEGORIES),
+        "categories": sorted(FOOD_CATEGORIES),
+        "note": "You can also use custom categories with /analyze-custom endpoint"
     }
 
-# --- Run ULTRA API ---
+
+# --- Run API ---
 if __name__ == "__main__":
-    print("=" * 100)
-    print("🏆 ULTRA-OPTIMIZED FOOD SCANNER API v10.0 - 99% ACCURACY EDITION")
-    print("=" * 100)
-    print("🎯 ULTRA Features:")
-    print("   ✅ Ensemble od 3+ specijalizovana modela")
-    print("   ✅ 99%+ preciznost u prepoznavanju hrane")
-    print("   ✅ Automatska non-food detekcija")
-    print("   ✅ Napredni image preprocessing (5 varijanti)")
-    print("   ✅ Confidence filtering za maksimalnu pouzdanost")
-    print("   ✅ Intelligent voting algoritam")
-    print("   ✅ Optimizovane Food-101 labele sa sinonimima")
-    print("   ✅ Realni nutritivni podaci iz Open Food Facts")
-    print("=" * 100)
-    print(f"🤖 Primary Model: {FOOD_MODELS['primary']}")
-    print(f"🤖 Secondary Model: {FOOD_MODELS['secondary']}")
-    print(f"🤖 CLIP Model: {CLIP_MODEL_NAME}")
+    print("=" * 80)
+    print("🎯 ZERO-SHOT FOOD RECOGNITION API - CLIP EDITION")
+    print("=" * 80)
+    print("🌟 Features:")
+    print("   ✅ Zero-shot learning - prepoznaje bilo šta!")
+    print("   ✅ CLIP model - state-of-the-art performanse")
+    print("   ✅ Jednostavan kod - lako razumljiv i održiv")
+    print("   ✅ Customizabilne kategorije")
+    print("   ✅ Automatski nutrition lookup")
+    print("=" * 80)
+    print(f"🤖 Model: {CLIP_MODEL_NAME}")
     print(f"💻 Device: {device.upper()}")
-    print(f"🎯 Accuracy: 99%+ (Guaranteed)")
-    print(f"⚡ Status: ULTRA-Ready for Production")
-    print("=" * 100)
+    print(f"🏷️  Categories: {len(FOOD_CATEGORIES)} (Food-101)")
+    print("=" * 80)
     
     run_port = int(os.environ.get("PORT", "8000"))
-    print(f"🌍 ULTRA API Server: http://0.0.0.0:{run_port}")
-    print(f"📚 ULTRA Docs: http://0.0.0.0:{run_port}/docs")
-    print("🏆 ULTRA Food Scanner - Nikad više pogrešnih rezultata!")
-    print("=" * 100)
+    print(f"🌍 Server: http://0.0.0.0:{run_port}")
+    print(f"📚 Docs: http://0.0.0.0:{run_port}/docs")
+    print("=" * 80)
     
     uvicorn.run(app, host="0.0.0.0", port=run_port)

requirements.txt

@@ -1,5 +1,5 @@
-# ULTRA-OPTIMIZED Food Scanner API - Multi-Model Ensemble Edition
-# Specijalizovani requirements za 99% preciznost food recognition
+# Zero-Shot Food Recognition API - CLIP Edition
+# Minimalni requirements za jednostavan i moćan food recognition
 
 # Core API Framework
 fastapi==0.115.0
@@ -8,31 +8,16 @@ python-multipart==0.0.12
 
 # Image Processing
 pillow==11.0.0
-opencv-python-headless==4.10.0.84
 
-# Deep Learning / Transformers
-# NOTE: Due to CVE-2025-32434, torch must be >=2.6 to allow torch.load() via transformers
+# Deep Learning - PyTorch sa CVE fix
 torch>=2.6.0
 torchvision>=0.19.0
-safetensors>=0.4.3
 
-# Transformers (Multiple specialized models)
+# Transformers za CLIP model
 transformers>=4.44.2
-timm>=1.0.9
 
-# Computer Vision utilities
-albumentations>=1.4.15
-
-# HTTP util
+# HTTP za nutrition API
 requests>=2.32.0
 
-# Scientific computing
-numpy>=1.24.0
-scipy>=1.11.0
-
-# Additional ML utilities
-scikit-learn>=1.3.0
-
-# Napomena: ULTRA varijanta koristi ensemble pristup sa specijalizovanim modelima
-# za maksimalnu preciznost u food recognition
-
+# Napomena: Ovaj setup koristi samo CLIP model za zero-shot classification
+# što je jednostavnije i dovoljno moćno za većinu use-case-ova