Deploy FastAPI Recipe AI Assistant

- Added FastAPI app with clean REST endpoints
- Integrated GPT-2 LoRA model from nutrientartcd/recipe-gpt2-lora
- Added CORS support for mobile app integration
- Added health checks and proper error handling
- Added automatic API documentation at /docs

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create non-root user for security
+RUN useradd -m -u 1000 user
+RUN chown -R user:user /app
+USER user
+
+# Expose port
+EXPOSE 7860
+
+# Set environment variables
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:7860/health || exit 1
+
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -1,10 +1,33 @@
 ---
-title: Recipe Ai Fastapi
-emoji: 🐠
-colorFrom: purple
-colorTo: gray
+title: Recipe AI FastAPI
+emoji: 🍳
+colorFrom: green
+colorTo: orange
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🍳 Recipe AI Assistant FastAPI
+
+A production-ready FastAPI service for AI-powered recipe recommendations using fine-tuned GPT-2.
+
+## Features
+
+- **Clean REST API** designed for mobile apps
+- **FastAPI with automatic docs** at `/docs`
+- **CORS enabled** for web and mobile access  
+- **Health checks** and error handling
+- **Multiple recommendations** with confidence scores
+
+## API Endpoints
+
+### `POST /api/recipe-suggestions`
+Get personalized recipe recommendations for mobile apps.
+
+### `GET /health`
+Health check endpoint for monitoring.
+
+## Model Integration
+
+Uses fine-tuned GPT-2 LoRA model from `nutrientartcd/recipe-gpt2-lora`.

app.py

@@ -0,0 +1,248 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from peft import PeftModel
+import uvicorn
+import os
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="🍳 Recipe AI Assistant API",
+    description="AI-powered recipe recommendations using fine-tuned GPT-2",
+    version="1.0.0"
+)
+
+# Add CORS middleware for web and mobile access
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, specify your domains
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for model
+tokenizer = None
+model = None
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# Request/Response Models
+class RecipeRequest(BaseModel):
+    ingredients: str
+    preferences: Optional[str] = ""
+    max_minutes: int = 30
+
+class RecipeRecommendation(BaseModel):
+    suggestion: str
+    confidence: float
+
+class RecipeResponse(BaseModel):
+    status: str
+    recommendations: List[RecipeRecommendation]
+    query: RecipeRequest
+    error: Optional[str] = None
+
+# Load model on startup
+@app.on_event("startup")
+async def load_model():
+    global tokenizer, model
+    
+    try:
+        print("🚀 Loading Recipe AI Model...")
+        
+        # Load tokenizer
+        tokenizer = AutoTokenizer.from_pretrained("gpt2")
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        
+        # Load base model
+        print("📦 Loading base GPT-2...")
+        base_model = AutoModelForCausalLM.from_pretrained("gpt2")
+        
+        # Load your fine-tuned LoRA adapter
+        print("🔧 Loading LoRA adapter...")
+        model = PeftModel.from_pretrained(
+            base_model, 
+            "nutrientartcd/recipe-gpt2-lora"
+        ).to(device)
+        model.eval()
+        
+        print(f"✅ Model loaded successfully on {device}!")
+        
+    except Exception as e:
+        print(f"❌ Error loading model: {e}")
+        print("🔄 Falling back to base GPT-2...")
+        
+        # Fallback to base model
+        tokenizer = AutoTokenizer.from_pretrained("gpt2")
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+        model = AutoModelForCausalLM.from_pretrained("gpt2").to(device)
+        model.eval()
+
+# Health check endpoint
+@app.get("/")
+async def root():
+    return {
+        "message": "🍳 Recipe AI Assistant API",
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "device": device
+    }
+
+# Health check endpoint
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "model_status": "loaded" if model is not None else "not_loaded",
+        "device": device
+    }
+
+# Main recipe recommendation endpoint
+@app.post("/api/recipe-suggestions", response_model=RecipeResponse)
+async def get_recipe_suggestions(request: RecipeRequest):
+    try:
+        if model is None or tokenizer is None:
+            raise HTTPException(status_code=503, detail="Model not loaded")
+        
+        print(f"📥 Recipe request: {request.ingredients}, prefs: {request.preferences}, time: {request.max_minutes}")
+        
+        # Generate recommendations
+        recommendations = await generate_recommendations(
+            request.ingredients, 
+            request.preferences, 
+            request.max_minutes
+        )
+        
+        return RecipeResponse(
+            status="success",
+            recommendations=recommendations,
+            query=request
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"❌ Error generating recommendations: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+async def generate_recommendations(
+    ingredients: str, 
+    preferences: str, 
+    max_minutes: int
+) -> List[RecipeRecommendation]:
+    """Generate recipe recommendations using the fine-tuned model"""
+    
+    try:
+        recommendations = []
+        
+        # Generate 3 diverse recommendations
+        for i in range(3):
+            # Build prompt in training format
+            user_input = []
+            if ingredients:
+                user_input.append(f"I have {ingredients}.")
+            user_input.append(f"I'm looking for something ready in about {max_minutes} minutes.")
+            if preferences:
+                user_input.append(f"Preferences: {preferences}.")
+            
+            user_prompt = " ".join(user_input)
+            prompt = f"User: {user_prompt}\nAssistant: "
+            
+            # Vary temperature for diversity
+            temperature = 0.7 + (i * 0.1)
+            
+            # Generate response
+            with torch.no_grad():
+                inputs = tokenizer(prompt, return_tensors="pt").to(device)
+                
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=150,
+                    temperature=temperature,
+                    top_p=0.95,
+                    do_sample=True,
+                    pad_token_id=tokenizer.eos_token_id,
+                    repetition_penalty=1.1
+                )
+                
+                # Decode response
+                full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+                
+                # Extract assistant response
+                assistant_start = full_response.find("Assistant:")
+                if assistant_start != -1:
+                    suggestion = full_response[assistant_start + len("Assistant:"):].strip()
+                else:
+                    suggestion = full_response.strip()
+                
+                # Calculate confidence (higher for first recommendations)
+                confidence = max(0.6, 1.0 - (i * 0.15))
+                
+                recommendations.append(
+                    RecipeRecommendation(
+                        suggestion=suggestion,
+                        confidence=confidence
+                    )
+                )
+        
+        return recommendations
+        
+    except Exception as e:
+        print(f"❌ Error in generate_recommendations: {e}")
+        # Return fallback recommendations
+        return [
+            RecipeRecommendation(
+                suggestion="I'm having trouble generating custom recipes right now. Here's a quick suggestion: try a simple stir-fry with your ingredients!",
+                confidence=0.5
+            )
+        ]
+
+# Ingredient parsing endpoint (bonus feature)
+@app.post("/api/parse-ingredients")
+async def parse_ingredients(text: dict):
+    """Parse ingredients from natural language text"""
+    try:
+        query = text.get("text", "")
+        
+        # Simple ingredient extraction (you can enhance this)
+        common_ingredients = [
+            "chicken", "beef", "pork", "fish", "salmon", "shrimp", "tofu",
+            "rice", "pasta", "quinoa", "bread", "potatoes",
+            "tomatoes", "onion", "garlic", "ginger", "peppers", "broccoli", 
+            "spinach", "carrots", "cheese", "milk", "eggs", "butter"
+        ]
+        
+        found_ingredients = [ing for ing in common_ingredients if ing in query.lower()]
+        
+        return {
+            "status": "success",
+            "ingredients": found_ingredients,
+            "original_text": query
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Recipe details endpoint (for future expansion)
+@app.get("/api/recipe/{recipe_id}")
+async def get_recipe_details(recipe_id: str):
+    """Get detailed recipe information (placeholder for future feature)"""
+    return {
+        "status": "success",
+        "message": "Recipe details endpoint - coming soon!",
+        "recipe_id": recipe_id
+    }
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    uvicorn.run(
+        "app:app", 
+        host="0.0.0.0", 
+        port=port,
+        reload=False
+    )

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+torch>=2.0.0
+transformers>=4.35.0
+peft>=0.7.0
+pydantic>=2.0.0
+python-multipart==0.0.6
+huggingface_hub>=0.19.0
+accelerate>=0.24.0
+safetensors>=0.4.0