Upload 6 files

README.md

@@ -1,13 +1,168 @@
----
-title: RAG DietAssistant
-emoji: 😻
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: AI Diet Planner & Nutrition Assistant
+emoji: 🍽️
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+short_description: AI-powered diet planning with nutrition analysis
+---
+
+# 🍽️ AI Diet Planner & Nutrition Assistant
+
+An intelligent diet planning application that uses RAG (Retrieval-Augmented Generation) technology to provide personalized nutrition advice, meal planning, and dietary recommendations.
+
+## ✨ Features
+
+### 🎯 **Personalized Diet Planning**
+- **Weekly Meal Plans**: Complete 7-day diet plans with detailed meal breakdowns
+- **Daily Nutrition**: Individual day meal planning with macro and micronutrient analysis
+- **Customizable Parameters**: Age, weight, height, activity level, and dietary preferences
+
+### 📊 **Nutrition Analysis**
+- **Comprehensive Nutrition Facts**: Detailed breakdown of calories, macronutrients, vitamins, and minerals
+- **USDA Food Database**: Access to extensive food nutrition information
+- **BMR & TDEE Calculations**: Accurate metabolic rate calculations using Mifflin-St Jeor formula
+
+### 🤖 **AI-Powered Recommendations**
+- **Smart Suggestions**: Personalized dietary recommendations based on your profile
+- **Goal-Oriented Planning**: Weight loss, muscle gain, or maintenance-focused plans
+- **Interactive Chat**: Natural language interface for easy interaction
+
+### 📋 **Advanced Features**
+- **JSON Export**: All plans and analyses saved as structured JSON files
+- **Table Formatting**: Beautiful markdown tables for easy reading
+- **Multi-language Support**: English interface with comprehensive food database
+
+## 🚀 How to Use
+
+### 1. **Create a Diet Plan**
+```
+"Create a weekly diet plan for a 25-year-old male, 70kg, 175cm, moderate activity"
+```
+
+### 2. **Calculate Nutrition**
+```
+"Calculate nutrition for 200g chicken breast and 150g rice"
+```
+
+### 3. **Get Recommendations**
+```
+"Get diet recommendations for weight loss"
+```
+
+### 4. **Vegetarian Options**
+```
+"Create a vegetarian meal plan for 7 days"
+```
+
+## 🔧 Technical Details
+
+### **Architecture**
+- **RAG System**: Retrieval-Augmented Generation for intelligent responses
+- **Groq API**: Fast LLM inference for real-time responses
+- **Sentence Transformers**: Semantic search for relevant nutrition data
+- **Gradio**: Modern web interface for easy interaction
+
+### **Data Sources**
+- **USDA FoodData Central**: Comprehensive nutrition database
+- **Custom Food Database**: Curated collection of common foods
+- **Nutritional Algorithms**: BMR, TDEE, and macro distribution calculations
+
+### **Output Formats**
+- **JSON Files**: Structured data for all plans and analyses
+- **Markdown Tables**: Human-readable formatted output
+- **Interactive Chat**: Real-time conversation interface
+
+## 📁 File Structure
+
+```
+├── app.py                 # Main Gradio application
+├── main3.py              # RAG system and tool router
+├── diet_tool.py          # Diet planning algorithms
+├── usda_provider.py      # USDA API integration
+├── requirements.txt      # Python dependencies
+├── README.md            # This file
+└── outputs/             # Generated JSON files
+    ├── diet_plan_weekly_*.json
+    ├── diet_plan_daily_*.json
+    └── diet_recommendations_*.json
+```
+
+## 🛠️ Setup Instructions
+
+### **For Hugging Face Spaces**
+
+1. **Create a new Space** on Hugging Face
+2. **Upload all files** to your Space repository
+3. **Set Environment Variables**:
+   - Go to Settings → Secrets
+   - Add `GROQ_API_KEY` with your Groq API key
+4. **Deploy** - The Space will automatically build and deploy
+
+### **For Local Development**
+
+1. **Install Dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Set Environment Variable**:
+   ```bash
+   export GROQ_API_KEY="your_groq_api_key_here"
+   ```
+
+3. **Run the Application**:
+   ```bash
+   python app.py
+   ```
+
+## 🔑 API Keys Required
+
+- **Groq API Key**: Get your free API key from [console.groq.com](https://console.groq.com)
+
+## 📊 Example Outputs
+
+### **Weekly Diet Plan**
+- 7-day meal breakdown
+- Daily calorie and macro targets
+- Detailed food lists with portions
+- Nutritional analysis per meal
+
+### **Nutrition Analysis**
+- Complete macronutrient breakdown
+- Vitamin and mineral content
+- Calorie calculations
+- Serving size recommendations
+
+### **Dietary Recommendations**
+- Personalized advice based on profile
+- Goal-specific suggestions
+- Macro distribution guidance
+- Lifestyle integration tips
+
+## 🤝 Contributing
+
+Feel free to contribute to this project by:
+- Adding new food items to the database
+- Improving nutrition calculation algorithms
+- Enhancing the user interface
+- Adding new dietary patterns (keto, paleo, etc.)
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🙏 Acknowledgments
+
+- **USDA FoodData Central** for comprehensive nutrition data
+- **Groq** for fast LLM inference
+- **Gradio** for the beautiful web interface
+- **Sentence Transformers** for semantic search capabilities
+
+---
+
+**Made with ❤️ for better nutrition and healthier living!**

diet_tool.py

@@ -0,0 +1,508 @@
+import json
+import random
+import math
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from usda_provider import fetch_nutrition_usda
+
+@dataclass
+class UserProfile:
+    """User profile information"""
+    age: int
+    sex: str  # "male" or "female"
+    height_cm: float
+    weight_kg: float
+    activity_level: str  # "sedentary", "light", "moderate", "active", "very_active"
+    goal: str  # "weight_loss", "muscle_gain", "maintenance", "keto", "mediterranean"
+    dietary_restrictions: List[str] = None
+    allergies: List[str] = None
+    preferences: List[str] = None
+
+@dataclass
+class MealPlan:
+    """Meal plan"""
+    meal_name: str
+    time_range: str
+    foods: List[Dict[str, Any]]
+    total_calories: float
+    total_protein: float
+    total_carbs: float
+    total_fat: float
+    total_fiber: float
+
+@dataclass
+class DailyPlan:
+    """Daily diet plan"""
+    date: str
+    meals: List[MealPlan]
+    total_calories: float
+    total_protein: float
+    total_carbs: float
+    total_fat: float
+    total_fiber: float
+
+class DietPlanner:
+    """Diet planner class"""
+    
+    def __init__(self, diet_data_file: str = "foods_DB_Example.json"):
+        """Load diet data"""
+        with open(diet_data_file, 'r', encoding='utf-8') as f:
+            self.diet_data = json.load(f)
+        
+        # Meal name translation mapping
+        self.meal_name_translation = {
+            "Kahvaltı": "Breakfast",
+            "Kuşluk": "Morning Snack", 
+            "Öğle Yemeği": "Lunch",
+            "İkindi": "Afternoon Snack",
+            "Akşam Yemeği": "Dinner",
+            "Gece Atıştırması": "Evening Snack"
+        }
+    
+    def calculate_bmr(self, profile: UserProfile) -> float:
+        """Calculate basal metabolic rate (Mifflin-St Jeor formula)"""
+        if profile.sex.lower() == "male":
+            bmr = 10 * profile.weight_kg + 6.25 * profile.height_cm - 5 * profile.age + 5
+        else:
+            bmr = 10 * profile.weight_kg + 6.25 * profile.height_cm - 5 * profile.age - 161
+        return bmr
+    
+    def calculate_tdee(self, profile: UserProfile) -> float:
+        """Calculate total daily energy expenditure"""
+        bmr = self.calculate_bmr(profile)
+        
+        activity_multipliers = {
+            "sedentary": 1.2,      # Sedentary
+            "light": 1.375,        # Lightly active
+            "moderate": 1.55,      # Moderately active
+            "active": 1.725,       # Active
+            "very_active": 1.9     # Very active
+        }
+        
+        multiplier = activity_multipliers.get(profile.activity_level.lower(), 1.2)
+        return bmr * multiplier
+    
+    def calculate_target_calories(self, profile: UserProfile) -> float:
+        """Calculate target calorie amount"""
+        tdee = self.calculate_tdee(profile)
+        
+        if profile.goal == "weight_loss":
+            # 15-20% calorie deficit
+            deficit = random.uniform(0.15, 0.20)
+            return tdee * (1 - deficit)
+        elif profile.goal == "muscle_gain":
+            # 10-15% calorie surplus
+            surplus = random.uniform(0.10, 0.15)
+            return tdee * (1 + surplus)
+        elif profile.goal == "keto":
+            # 10-15% calorie deficit
+            deficit = random.uniform(0.10, 0.15)
+            return tdee * (1 - deficit)
+        else:
+            # Maintenance and Mediterranean
+            return tdee
+    
+    def get_macro_ratios(self, profile: UserProfile) -> Dict[str, float]:
+        """Get macronutrient ratios"""
+        diet_type = self.diet_data["diet_types"].get(profile.goal, {})
+        
+        if profile.goal == "weight_loss":
+            return {
+                "protein": random.uniform(0.25, 0.30),
+                "carbs": random.uniform(0.40, 0.45),
+                "fat": random.uniform(0.25, 0.30)
+            }
+        elif profile.goal == "muscle_gain":
+            return {
+                "protein": random.uniform(0.25, 0.30),
+                "carbs": random.uniform(0.45, 0.55),
+                "fat": random.uniform(0.20, 0.25)
+            }
+        elif profile.goal == "keto":
+            return {
+                "protein": random.uniform(0.20, 0.25),
+                "carbs": random.uniform(0.05, 0.10),
+                "fat": random.uniform(0.70, 0.75)
+            }
+        else:
+            return {
+                "protein": random.uniform(0.20, 0.25),
+                "carbs": random.uniform(0.45, 0.55),
+                "fat": random.uniform(0.25, 0.30)
+            }
+    
+    def get_available_foods(self, profile: UserProfile) -> Dict[str, List[Dict]]:
+        """Filter foods that the user can eat"""
+        available_foods = {}
+        
+        for category, subcategories in self.diet_data["foods"].items():
+            available_foods[category] = []
+            
+            for subcategory, foods in subcategories.items():
+                for food in foods:
+                    # Allergy check
+                    if profile.allergies:
+                        food_name_lower = food["name"].lower()
+                        if any(allergy.lower() in food_name_lower for allergy in profile.allergies):
+                            continue
+                    
+                    # Dietary restrictions check
+                    if profile.dietary_restrictions:
+                        if "vegetarian" in profile.dietary_restrictions and category == "protein_sources":
+                            if subcategory in ["lean_meats", "fish_seafood"]:
+                                continue
+                        if "vegan" in profile.dietary_restrictions and category in ["protein_sources", "dairy"]:
+                            if subcategory in ["lean_meats", "fish_seafood", "eggs", "milk_products", "cheese"]:
+                                continue
+                    
+                    # Calorie value check (prevent division by zero)
+                    if food.get("calories_per_100g", 0) <= 0:
+                        continue
+                    
+                    available_foods[category].append(food)
+        
+        return available_foods
+    
+    def select_foods_for_meal(self, meal_type: str, target_calories: float, 
+                            macro_ratios: Dict[str, float], available_foods: Dict[str, List[Dict]]) -> List[Dict[str, Any]]:
+        """Select foods for meal"""
+        meal_info = self.diet_data["meals"][meal_type]
+        food_categories = meal_info["food_categories"]
+        
+        selected_foods = []
+        remaining_calories = target_calories
+        
+        # Select food for each category
+        for category in food_categories:
+            if category not in available_foods or not available_foods[category]:
+                continue
+            
+            # Calorie target for category
+            category_calories = remaining_calories * 0.3  # 30% for each category
+            
+            if category_calories < 50:  # If very few calories left
+                continue
+            
+            # Randomly select food from category
+            food = random.choice(available_foods[category])
+            
+            # Calculate portion amount (with division by zero check)
+            if food["calories_per_100g"] <= 0:
+                continue  # Skip foods with 0 or negative calorie values
+            
+            portion_grams = min(category_calories / (food["calories_per_100g"] / 100), 200)
+            
+            # Minimum portion check
+            if portion_grams < 20:
+                continue
+            
+            selected_food = {
+                "name": food["name"],
+                "portion_grams": round(portion_grams, 1),
+                "calories": round(food["calories_per_100g"] * portion_grams / 100, 1),
+                "protein": round(food["protein_per_100g"] * portion_grams / 100, 1),
+                "carbs": round(food["carbs_per_100g"] * portion_grams / 100, 1),
+                "fat": round(food["fat_per_100g"] * portion_grams / 100, 1),
+                "fiber": round(food["fiber_per_100g"] * portion_grams / 100, 1),
+                "vitamins": food["vitamins"],
+                "minerals": food["minerals"]
+            }
+            
+            selected_foods.append(selected_food)
+            remaining_calories -= selected_food["calories"]
+            
+            if remaining_calories < 100:  # Stop if very few calories left
+                break
+        
+        return selected_foods
+    
+    def create_meal_plan(self, meal_type: str, target_calories: float, 
+                        macro_ratios: Dict[str, float], available_foods: Dict[str, List[Dict]]) -> MealPlan:
+        """Create meal plan"""
+        meal_info = self.diet_data["meals"][meal_type]
+        foods = self.select_foods_for_meal(meal_type, target_calories, macro_ratios, available_foods)
+        
+        # Calculate total nutritional values
+        total_calories = sum(food["calories"] for food in foods)
+        total_protein = sum(food["protein"] for food in foods)
+        total_carbs = sum(food["carbs"] for food in foods)
+        total_fat = sum(food["fat"] for food in foods)
+        total_fiber = sum(food["fiber"] for food in foods)
+        
+        # Translate meal name to English
+        meal_name = self.meal_name_translation.get(meal_info["name"], meal_info["name"])
+        
+        return MealPlan(
+            meal_name=meal_name,
+            time_range=meal_info["time_range"],
+            foods=foods,
+            total_calories=round(total_calories, 1),
+            total_protein=round(total_protein, 1),
+            total_carbs=round(total_carbs, 1),
+            total_fat=round(total_fat, 1),
+            total_fiber=round(total_fiber, 1)
+        )
+    
+    def generate_daily_plan(self, profile: UserProfile) -> DailyPlan:
+        """Generate daily diet plan"""
+        target_calories = self.calculate_target_calories(profile)
+        macro_ratios = self.get_macro_ratios(profile)
+        available_foods = self.get_available_foods(profile)
+        
+        # Determine meal types
+        meal_types = ["breakfast", "lunch", "dinner"]
+        
+        # Add snacks
+        if profile.goal == "muscle_gain":
+            meal_types.extend(["morning_snack", "afternoon_snack", "evening_snack"])
+        elif profile.goal == "weight_loss":
+            meal_types.append("morning_snack")
+        else:
+            meal_types.extend(["morning_snack", "afternoon_snack"])
+        
+        meals = []
+        total_calories = 0
+        total_protein = 0
+        total_carbs = 0
+        total_fat = 0
+        total_fiber = 0
+        
+        for meal_type in meal_types:
+            # Calorie target for meal
+            meal_calories = target_calories * float(self.diet_data["meals"][meal_type]["calorie_target"].split("-")[0]) / 100
+            
+            meal_plan = self.create_meal_plan(meal_type, meal_calories, macro_ratios, available_foods)
+            meals.append(meal_plan)
+            
+            total_calories += meal_plan.total_calories
+            total_protein += meal_plan.total_protein
+            total_carbs += meal_plan.total_carbs
+            total_fat += meal_plan.total_fat
+            total_fiber += meal_plan.total_fiber
+        
+        return DailyPlan(
+            date=datetime.now().strftime("%Y-%m-%d"),
+            meals=meals,
+            total_calories=round(total_calories, 1),
+            total_protein=round(total_protein, 1),
+            total_carbs=round(total_carbs, 1),
+            total_fat=round(total_fat, 1),
+            total_fiber=round(total_fiber, 1)
+        )
+    
+    def generate_weekly_plan(self, profile: UserProfile) -> List[DailyPlan]:
+        """Generate weekly diet plan"""
+        weekly_plan = []
+        
+        for i in range(7):
+            # Create different variations for each day
+            daily_plan = self.generate_daily_plan(profile)
+            daily_plan.date = (datetime.now() + timedelta(days=i)).strftime("%Y-%m-%d")
+            weekly_plan.append(daily_plan)
+        
+        return weekly_plan
+    
+    def plan_to_dict(self, plan: DailyPlan) -> Dict[str, Any]:
+        """Convert plan to dictionary format"""
+        return {
+            "date": plan.date,
+            "meals": [
+                {
+                    "meal_name": meal.meal_name,
+                    "time_range": meal.time_range,
+                    "foods": meal.foods,
+                    "nutrition": {
+                        "calories": meal.total_calories,
+                        "protein": meal.total_protein,
+                        "carbs": meal.total_carbs,
+                        "fat": meal.total_fat,
+                        "fiber": meal.total_fiber
+                    }
+                }
+                for meal in plan.meals
+            ],
+            "daily_totals": {
+                "calories": plan.total_calories,
+                "protein": plan.total_protein,
+                "carbs": plan.total_carbs,
+                "fat": plan.total_fat,
+                "fiber": plan.total_fiber
+            }
+        }
+
+def generate_diet_plan(user_profile: Dict[str, Any], plan_type: str = "daily") -> Dict[str, Any]:
+    """
+    Create diet plan
+    
+    Args:
+        user_profile: User profile information
+        plan_type: "daily" or "weekly"
+    
+    Returns:
+        Diet plan dictionary
+    """
+    try:
+        # Create UserProfile object
+        profile = UserProfile(
+            age=user_profile["age"],
+            sex=user_profile["sex"],
+            height_cm=user_profile["height_cm"],
+            weight_kg=user_profile["weight_kg"],
+            activity_level=user_profile["activity_level"],
+            goal=user_profile["goal"],
+            dietary_restrictions=user_profile.get("dietary_restrictions", []),
+            allergies=user_profile.get("allergies", []),
+            preferences=user_profile.get("preferences", [])
+        )
+        
+        # Create DietPlanner
+        planner = DietPlanner()
+        
+        if plan_type == "weekly":
+            plans = planner.generate_weekly_plan(profile)
+            return {
+                "plan_type": "weekly",
+                "plans": [planner.plan_to_dict(plan) for plan in plans]
+            }
+        else:
+            plan = planner.generate_daily_plan(profile)
+            return {
+                "plan_type": "daily",
+                "plan": planner.plan_to_dict(plan)
+            }
+    
+    except Exception as e:
+        return {
+            "error": f"Error while creating diet plan: {str(e)}"
+        }
+
+def calculate_nutrition_info(food_name: str, portion_grams: float) -> Dict[str, Any]:
+    """
+    Calculate nutritional values for a specific food
+    
+    Args:
+        food_name: Food name
+        portion_grams: Portion amount (grams)
+    
+    Returns:
+        Nutritional values dictionary
+    """
+    try:
+        planner = DietPlanner()
+        
+        # Find the food
+        for category, subcategories in planner.diet_data["foods"].items():
+            for subcategory, foods in subcategories.items():
+                for food in foods:
+                    if food["name"].lower() == food_name.lower():
+                        return {
+                            "food_name": food["name"],
+                            "portion_grams": portion_grams,
+                            "calories": round(food["calories_per_100g"] * portion_grams / 100, 1),
+                            "protein": round(food["protein_per_100g"] * portion_grams / 100, 1),
+                            "carbs": round(food["carbs_per_100g"] * portion_grams / 100, 1),
+                            "fat": round(food["fat_per_100g"] * portion_grams / 100, 1),
+                            "fiber": round(food["fiber_per_100g"] * portion_grams / 100, 1),
+                            "vitamins": food["vitamins"],
+                            "minerals": food["minerals"]
+                        }
+        # If not found locally, get from USDA
+        usda = fetch_nutrition_usda(food_name, portion_grams)
+        if usda:
+            return {
+                "food_name": food_name,
+                "portion_grams": usda.get("portion_grams", portion_grams),
+                "calories": usda.get("calories"),
+                "protein": usda.get("protein"),
+                "carbs": usda.get("carbs"),
+                "fat": usda.get("fat"),
+                "fiber": usda.get("fiber"),
+                "vitamins": usda.get("vitamins", {}),
+                "minerals": usda.get("minerals", {}),
+                "source": "USDA",
+                "fdc_id": usda.get("fdc_id"),
+                "description": usda.get("description"),
+            }
+        return {"error": f"'{food_name}' not found (local and USDA)"}
+    
+    except Exception as e:
+        return {"error": f"Error while calculating nutritional value: {str(e)}"}
+
+def get_diet_recommendations(user_profile: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Create diet recommendations for user
+    
+    Args:
+        user_profile: User profile information
+    
+    Returns:
+        Diet recommendations dictionary
+    """
+    try:
+        profile = UserProfile(
+            age=user_profile["age"],
+            sex=user_profile["sex"],
+            height_cm=user_profile["height_cm"],
+            weight_kg=user_profile["weight_kg"],
+            activity_level=user_profile["activity_level"],
+            goal=user_profile["goal"],
+            dietary_restrictions=user_profile.get("dietary_restrictions", []),
+            allergies=user_profile.get("allergies", []),
+            preferences=user_profile.get("preferences", [])
+        )
+        
+        planner = DietPlanner()
+        
+        bmr = planner.calculate_bmr(profile)
+        tdee = planner.calculate_tdee(profile)
+        target_calories = planner.calculate_target_calories(profile)
+        macro_ratios = planner.get_macro_ratios(profile)
+        
+        return {
+            "bmr": round(bmr, 1),
+            "tdee": round(tdee, 1),
+            "target_calories": round(target_calories, 1),
+            "macro_ratios": {
+                "protein": f"{macro_ratios['protein']*100:.1f}%",
+                "carbs": f"{macro_ratios['carbs']*100:.1f}%",
+                "fat": f"{macro_ratios['fat']*100:.1f}%"
+            },
+            "macro_grams": {
+                "protein": round(target_calories * macro_ratios["protein"] / 4, 1),
+                "carbs": round(target_calories * macro_ratios["carbs"] / 4, 1),
+                "fat": round(target_calories * macro_ratios["fat"] / 9, 1)
+            },
+            "recommendations": {
+                "meal_frequency": planner.diet_data["diet_types"][profile.goal]["meal_frequency"],
+                "fiber_target": planner.diet_data["diet_types"][profile.goal]["fiber_target"]
+            }
+        }
+    
+    except Exception as e:
+        return {"error": f"Error while creating recommendations: {str(e)}"}
+
+# Test function
+if __name__ == "__main__":
+    # Example user profile
+    test_profile = {
+        "age": 30,
+        "sex": "male",
+        "height_cm": 175,
+        "weight_kg": 75,
+        "activity_level": "moderate",
+        "goal": "weight_loss",
+        "dietary_restrictions": [],
+        "allergies": [],
+        "preferences": []
+    }
+    
+    # Create daily plan
+    daily_plan = generate_diet_plan(test_profile, "daily")
+    print("Daily Diet Plan:")
+    print(json.dumps(daily_plan, ensure_ascii=False, indent=2))
+    
+    # Get recommendations
+    recommendations = get_diet_recommendations(test_profile)
+    print("\nDiet Recommendations:")
+    print(json.dumps(recommendations, ensure_ascii=False, indent=2)) 

gradio_app_simple.py

@@ -0,0 +1,772 @@
+import gradio as gr
+import json
+import os
+import pandas as pd
+import re
+import glob
+from typing import Dict, List, Any
+from main3 import run_rag_tool_router, execute_diet_tool
+from diet_tool import generate_diet_plan, get_diet_recommendations, calculate_nutrition_info
+
+# Global chat history
+chat_history = []
+
+def format_json_to_table(json_data: Any, title: str = "") -> str:
+    """Convert JSON data to a formatted table string"""
+    if not json_data:
+        return ""
+    
+    try:
+        if isinstance(json_data, str):
+            json_data = json.loads(json_data)
+        
+        if isinstance(json_data, dict):
+            return format_dict_to_table(json_data, title)
+        elif isinstance(json_data, list):
+            return format_list_to_table(json_data, title)
+        else:
+            return str(json_data)
+    except:
+        return str(json_data)
+
+def format_dict_to_table(data: dict, title: str = "") -> str:
+    """Format dictionary as a table"""
+    if not data:
+        return ""
+    
+    result = f"## {title}\n\n" if title else ""
+    
+    # Check if it's a simple key-value dict
+    if all(not isinstance(v, (dict, list)) for v in data.values()):
+        result += "| Key | Value |\n"
+        result += "|-----|-------|\n"
+        for key, value in data.items():
+            result += f"| **{key}** | {value} |\n"
+    else:
+        # Complex nested structure
+        for key, value in data.items():
+            if isinstance(value, dict):
+                result += f"### {key}\n"
+                result += format_dict_to_table(value)
+            elif isinstance(value, list):
+                result += f"### {key}\n"
+                result += format_list_to_table(value)
+            else:
+                result += f"**{key}**: {value}\n"
+    
+    return result
+
+def format_list_to_table(data: list, title: str = "") -> str:
+    """Format list as a table"""
+    if not data:
+        return ""
+    
+    result = f"## {title}\n\n" if title else ""
+    
+    if not data:
+        return result
+    
+    # Check if all items are dictionaries with similar keys
+    if all(isinstance(item, dict) for item in data):
+        # Get all unique keys
+        all_keys = set()
+        for item in data:
+            all_keys.update(item.keys())
+        
+        if all_keys:
+            # Create table header
+            result += "| " + " | ".join(all_keys) + " |\n"
+            result += "|" + "|".join(["---"] * len(all_keys)) + "|\n"
+            
+            # Add rows
+            for item in data:
+                row = []
+                for key in all_keys:
+                    value = item.get(key, "")
+                    if isinstance(value, (dict, list)):
+                        value = json.dumps(value, ensure_ascii=False)[:50] + "..."
+                    row.append(str(value))
+                result += "| " + " | ".join(row) + " |\n"
+        else:
+            result += "Empty list\n"
+    else:
+        # Simple list
+        for i, item in enumerate(data):
+            result += f"{i+1}. {item}\n"
+    
+    return result
+
+def format_diet_plan_result(result: dict) -> str:
+    """Format diet plan result specifically"""
+    if not result or "error" in result:
+        return f"❌ Error: {result.get('error', 'Unknown error')}"
+    
+    formatted = "## 🍽️ Diet Plan\n\n"
+    
+    if "plan_type" in result:
+        formatted += f"**Plan Type**: {result['plan_type']}\n\n"
+    
+    if "plan" in result:
+        plan = result["plan"]
+        
+        # Daily totals
+        if "daily_totals" in plan:
+            totals = plan["daily_totals"]
+            formatted += "### 📊 Daily Nutrition Summary\n\n"
+            formatted += "| Nutrient | Amount |\n"
+            formatted += "|----------|--------|\n"
+            formatted += f"| **Calories** | {totals.get('calories', 0)} kcal |\n"
+            formatted += f"| **Protein** | {totals.get('protein', 0)} g |\n"
+            formatted += f"| **Carbs** | {totals.get('carbs', 0)} g |\n"
+            formatted += f"| **Fat** | {totals.get('fat', 0)} g |\n"
+            formatted += f"| **Fiber** | {totals.get('fiber', 0)} g |\n\n"
+        
+        # Meals
+        if "meals" in plan:
+            formatted += "### 🍽️ Meals\n\n"
+            for meal in plan["meals"]:
+                formatted += f"#### {meal.get('meal_name', 'Meal')} ({meal.get('time_range', '')})\n\n"
+                
+                # Meal nutrition
+                if "nutrition" in meal:
+                    nutrition = meal["nutrition"]
+                    formatted += "**Nutrition**: "
+                    formatted += f"{nutrition.get('calories', 0)} kcal, "
+                    formatted += f"{nutrition.get('protein', 0)}g protein, "
+                    formatted += f"{nutrition.get('carbs', 0)}g carbs, "
+                    formatted += f"{nutrition.get('fat', 0)}g fat\n\n"
+                
+                # Foods
+                if "foods" in meal:
+                    formatted += "**Foods**:\n"
+                    for food in meal["foods"]:
+                        formatted += f"- **{food.get('name', 'Unknown')}** "
+                        formatted += f"({food.get('portion_grams', 0)}g) - "
+                        formatted += f"{food.get('calories', 0)} kcal\n"
+                    formatted += "\n"
+    
+    elif "plans" in result:
+        # Weekly plan
+        plans = result["plans"]
+        formatted += f"### 📅 Weekly Plan ({len(plans)} days)\n\n"
+        
+        for i, plan in enumerate(plans[:3]):  # Show first 3 days
+            formatted += f"#### Day {i+1} - {plan.get('date', '')}\n"
+            if "daily_totals" in plan:
+                totals = plan["daily_totals"]
+                formatted += f"**Total**: {totals.get('calories', 0)} kcal, "
+                formatted += f"{totals.get('protein', 0)}g protein\n\n"
+        
+        if len(plans) > 3:
+            formatted += f"... and {len(plans) - 3} more days\n\n"
+    
+    return formatted
+
+def format_recommendations_result(result: dict) -> str:
+    """Format recommendations result specifically"""
+    if not result or "error" in result:
+        return f"❌ Error: {result.get('error', 'Unknown error')}"
+    
+    formatted = "## 📊 Diet Recommendations\n\n"
+    
+    # Basic metrics
+    if "bmr" in result:
+        formatted += f"**BMR (Basal Metabolic Rate)**: {result['bmr']} kcal/day\n"
+    if "tdee" in result:
+        formatted += f"**TDEE (Total Daily Energy Expenditure)**: {result['tdee']} kcal/day\n"
+    if "target_calories" in result:
+        formatted += f"**Target Calories**: {result['target_calories']} kcal/day\n\n"
+    
+    # Macro ratios
+    if "macro_ratios" in result:
+        ratios = result["macro_ratios"]
+        formatted += "### 🎯 Macro Ratios\n\n"
+        formatted += "| Macronutrient | Percentage |\n"
+        formatted += "|---------------|------------|\n"
+        for macro, ratio in ratios.items():
+            formatted += f"| **{macro.title()}** | {ratio} |\n"
+        formatted += "\n"
+    
+    # Macro grams
+    if "macro_grams" in result:
+        grams = result["macro_grams"]
+        formatted += "### ⚖️ Daily Macro Targets (grams)\n\n"
+        formatted += "| Macronutrient | Grams |\n"
+        formatted += "|---------------|-------|\n"
+        for macro, grams_val in grams.items():
+            formatted += f"| **{macro.title()}** | {grams_val} g |\n"
+        formatted += "\n"
+    
+    # Recommendations
+    if "recommendations" in result:
+        recs = result["recommendations"]
+        formatted += "### 💡 Recommendations\n\n"
+        for key, value in recs.items():
+            formatted += f"**{key.replace('_', ' ').title()}**: {value}\n"
+    
+    return formatted
+
+def format_nutrition_result(result: dict) -> str:
+    """Format nutrition calculation result specifically"""
+    if not result or "error" in result:
+        return f"❌ Error: {result.get('error', 'Unknown error')}"
+    
+    formatted = "## 🧮 Nutrition Information\n\n"
+    
+    if "food_name" in result:
+        formatted += f"**Food**: {result['food_name']}\n"
+    if "portion_grams" in result:
+        formatted += f"**Portion**: {result['portion_grams']} grams\n\n"
+    
+    # Basic nutrition
+    formatted += "### 📊 Nutritional Values\n\n"
+    formatted += "| Nutrient | Amount |\n"
+    formatted += "|----------|--------|\n"
+    
+    nutrients = ["calories", "protein", "carbs", "fat", "fiber"]
+    for nutrient in nutrients:
+        if nutrient in result:
+            unit = "kcal" if nutrient == "calories" else "g"
+            formatted += f"| **{nutrient.title()}** | {result[nutrient]} {unit} |\n"
+    
+    # Vitamins and minerals
+    if "vitamins" in result and result["vitamins"]:
+        formatted += "\n### 🥕 Vitamins\n\n"
+        if isinstance(result["vitamins"], list):
+            for vitamin in result["vitamins"]:
+                formatted += f"- {vitamin}\n"
+        else:
+            formatted += str(result["vitamins"])
+    
+    if "minerals" in result and result["minerals"]:
+        formatted += "\n### ⚡ Minerals\n\n"
+        if isinstance(result["minerals"], list):
+            for mineral in result["minerals"]:
+                formatted += f"- {mineral}\n"
+        else:
+            formatted += str(result["minerals"])
+    
+    return formatted
+
+def load_latest_json_output() -> str:
+    """Load and format the latest JSON output file"""
+    outputs_dir = "outputs"
+    if not os.path.exists(outputs_dir):
+        return "❌ No outputs directory found"
+    
+    # Get all JSON files in outputs directory
+    json_files = glob.glob(os.path.join(outputs_dir, "*.json"))
+    if not json_files:
+        return "❌ No JSON files found in outputs directory"
+    
+    # Sort by modification time and get the latest
+    latest_file = max(json_files, key=os.path.getmtime)
+    
+    try:
+        with open(latest_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Extract filename for title
+        filename = os.path.basename(latest_file)
+        
+        # Format based on file type
+        if "diet_plan" in filename:
+            if "weekly" in filename:
+                return format_weekly_diet_plan(data, filename)
+            else:
+                return format_daily_diet_plan(data, filename)
+        elif "recommendations" in filename:
+            return format_recommendations_result(data, filename)
+        elif "nutrition" in filename:
+            return format_nutrition_result(data, filename)
+        else:
+            return format_json_data_to_table(data, f"Latest Output: {filename}")
+            
+    except Exception as e:
+        return f"❌ Error reading {latest_file}: {str(e)}"
+
+def format_weekly_diet_plan(data: dict, filename: str) -> str:
+    """Format weekly diet plan from JSON file"""
+    if not data or "result" not in data:
+        return f"❌ Invalid data in {filename}"
+    
+    result = data["result"]
+    if "plans" not in result:
+        return f"❌ No plans found in {filename}"
+    
+    plans = result["plans"]
+    formatted = f"## 📅 Weekly Diet Plan ({len(plans)} days)\n\n"
+    formatted += f"**File**: {filename}\n\n"
+    
+    # Summary table for all days
+    formatted += "### 📊 Weekly Summary\n\n"
+    formatted += "| Day | Date | Calories | Protein | Carbs | Fat | Fiber |\n"
+    formatted += "|-----|------|----------|---------|-------|-----|-------|\n"
+    
+    for i, plan in enumerate(plans):
+        totals = plan.get("daily_totals", {})
+        date = plan.get("date", f"Day {i+1}")
+        formatted += f"| {i+1} | {date} | {totals.get('calories', 0)} | {totals.get('protein', 0)}g | {totals.get('carbs', 0)}g | {totals.get('fat', 0)}g | {totals.get('fiber', 0)}g |\n"
+    
+    # Detailed view for all days
+    formatted += "\n### 🍽️ Detailed Meals (All Days)\n\n"
+    
+    for i, plan in enumerate(plans):
+        date = plan.get("date", f"Day {i+1}")
+        formatted += f"#### Day {i+1} - {date}\n\n"
+        
+        meals = plan.get("meals", [])
+        for meal in meals:
+            meal_name = meal.get("meal_name", "Meal")
+            time_range = meal.get("time_range", "")
+            nutrition = meal.get("nutrition", {})
+            
+            formatted += f"**{meal_name}** ({time_range})\n"
+            formatted += f"- Calories: {nutrition.get('calories', 0)} | Protein: {nutrition.get('protein', 0)}g | Carbs: {nutrition.get('carbs', 0)}g | Fat: {nutrition.get('fat', 0)}g\n"
+            
+            # Foods
+            foods = meal.get("foods", [])
+            if foods:
+                formatted += "  - Foods: "
+                food_names = [f.get("name", "Unknown") for f in foods[:3]]  # Show first 3 foods
+                formatted += ", ".join(food_names)
+                if len(foods) > 3:
+                    formatted += f" (+{len(foods)-3} more)"
+                formatted += "\n"
+            formatted += "\n"
+    
+    return formatted
+
+def format_daily_diet_plan(data: dict, filename: str) -> str:
+    """Format daily diet plan from JSON file"""
+    if not data or "result" not in data:
+        return f"❌ Invalid data in {filename}"
+    
+    result = data["result"]
+    if "plan" not in result:
+        return f"❌ No plan found in {filename}"
+    
+    plan = result["plan"]
+    formatted = f"## 🍽️ Daily Diet Plan\n\n"
+    formatted += f"**File**: {filename}\n\n"
+    
+    # Daily totals
+    if "daily_totals" in plan:
+        totals = plan["daily_totals"]
+        formatted += "### 📊 Daily Nutrition Summary\n\n"
+        formatted += "| Nutrient | Amount |\n"
+        formatted += "|----------|--------|\n"
+        formatted += f"| **Calories** | {totals.get('calories', 0)} kcal |\n"
+        formatted += f"| **Protein** | {totals.get('protein', 0)} g |\n"
+        formatted += f"| **Carbs** | {totals.get('carbs', 0)} g |\n"
+        formatted += f"| **Fat** | {totals.get('fat', 0)} g |\n"
+        formatted += f"| **Fiber** | {totals.get('fiber', 0)} g |\n\n"
+    
+    # Meals
+    if "meals" in plan:
+        formatted += "### 🍽️ Meals\n\n"
+        for meal in plan["meals"]:
+            meal_name = meal.get("meal_name", "Meal")
+            time_range = meal.get("time_range", "")
+            nutrition = meal.get("nutrition", {})
+            
+            formatted += f"#### {meal_name} ({time_range})\n\n"
+            formatted += f"**Nutrition**: {nutrition.get('calories', 0)} kcal, {nutrition.get('protein', 0)}g protein, {nutrition.get('carbs', 0)}g carbs, {nutrition.get('fat', 0)}g fat\n\n"
+            
+            # Foods
+            foods = meal.get("foods", [])
+            if foods:
+                formatted += "**Foods**:\n"
+                for food in foods:
+                    name = food.get("name", "Unknown")
+                    portion = food.get("portion_grams", 0)
+                    calories = food.get("calories", 0)
+                    formatted += f"- **{name}** ({portion}g) - {calories} kcal\n"
+                formatted += "\n"
+    
+    return formatted
+
+def list_all_json_outputs() -> str:
+    """List all JSON output files with their details"""
+    outputs_dir = "outputs"
+    if not os.path.exists(outputs_dir):
+        return "❌ No outputs directory found"
+    
+    json_files = glob.glob(os.path.join(outputs_dir, "*.json"))
+    if not json_files:
+        return "❌ No JSON files found in outputs directory"
+    
+    # Sort by modification time (newest first)
+    json_files.sort(key=os.path.getmtime, reverse=True)
+    
+    formatted = "## 📁 Available JSON Outputs\n\n"
+    formatted += "| File | Type | Size | Modified |\n"
+    formatted += "|------|------|------|----------|\n"
+    
+    for file_path in json_files:
+        filename = os.path.basename(file_path)
+        file_type = "Unknown"
+        
+        if "diet_plan_weekly" in filename:
+            file_type = "Weekly Diet Plan"
+        elif "diet_plan_daily" in filename:
+            file_type = "Daily Diet Plan"
+        elif "recommendations" in filename:
+            file_type = "Recommendations"
+        elif "nutrition" in filename:
+            file_type = "Nutrition Info"
+        
+        file_size = os.path.getsize(file_path)
+        mod_time = os.path.getmtime(file_path)
+        mod_date = pd.Timestamp.fromtimestamp(mod_time).strftime("%Y-%m-%d %H:%M")
+        
+        formatted += f"| {filename} | {file_type} | {file_size:,} bytes | {mod_date} |\n"
+    
+    return formatted
+
+def extract_and_format_json_in_text(text: str) -> str:
+    """Extract JSON objects from text and format them as tables"""
+    if not text:
+        return text
+    
+    formatted_text = text
+    
+    # First, try to find JSON in code blocks
+    code_block_pattern = r'```(?:json)?\s*(\{.*?\})\s*```'
+    matches = list(re.finditer(code_block_pattern, formatted_text, re.DOTALL | re.IGNORECASE))
+    
+    for match in reversed(matches):
+        json_str = match.group(1).strip()
+        try:
+            json_data = json.loads(json_str)
+            table = format_json_data_to_table(json_data)
+            formatted_text = formatted_text[:match.start()] + table + formatted_text[match.end():]
+        except:
+            continue
+    
+    # Then, try to find standalone JSON objects
+    # Look for patterns that start with { and end with }
+    json_pattern = r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}'
+    matches = list(re.finditer(json_pattern, formatted_text, re.DOTALL))
+    
+    for match in reversed(matches):
+        json_str = match.group(0).strip()
+        
+        # Skip if it's already been processed or is too short
+        if len(json_str) < 10 or '|' in json_str:
+            continue
+            
+        try:
+            json_data = json.loads(json_str)
+            # Only format if it looks like structured data
+            if isinstance(json_data, (dict, list)) and len(str(json_data)) > 20:
+                table = format_json_data_to_table(json_data)
+                formatted_text = formatted_text[:match.start()] + table + formatted_text[match.end():]
+        except:
+            continue
+    
+    return formatted_text
+
+def format_json_data_to_table(json_data: Any) -> str:
+    """Format JSON data to a table string"""
+    if isinstance(json_data, dict):
+        return format_dict_to_table(json_data, "Data")
+    elif isinstance(json_data, list):
+        return format_list_to_table(json_data, "Data")
+    else:
+        return str(json_data)
+
+def process_user_input(user_input: str, history: List) -> tuple:
+    """Process user input through RAG system"""
+    global chat_history
+    
+    if not user_input.strip():
+        return history, ""
+    
+    # Convert Gradio history format to our format
+    rag_history = []
+    for msg in history:
+        if isinstance(msg, dict):
+            rag_history.append(msg)
+        else:
+            # Handle old format
+            user_msg, bot_msg = msg
+            rag_history.append({"role": "user", "content": user_msg})
+            rag_history.append({"role": "assistant", "content": bot_msg})
+    
+    # Process through RAG system
+    result = run_rag_tool_router(user_input, rag_history)
+    
+    # Update our chat history
+    chat_history.append({"role": "user", "content": user_input})
+    
+    # Handle different response types
+    if isinstance(result, dict) and "final" in result:
+        response = result["final"]
+        # Format any JSON in the response
+        formatted_response = extract_and_format_json_in_text(response)
+        chat_history.append({"role": "assistant", "content": formatted_response})
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": formatted_response})
+        return history, ""
+    
+    elif isinstance(result, dict) and "action" in result:
+        action = result["action"]
+        args = result.get("args", {})
+        
+        # Show the action being taken
+        action_response = f"**Executing**: {action}\n\n**Arguments**:\n```json\n{json.dumps(args, indent=2)}\n```"
+        
+        # Execute diet tools
+        if action in ["generate_diet_plan", "get_diet_recommendations", "calculate_nutrition_info", "expand_diet_database"]:
+            diet_result = execute_diet_tool(action, args)
+            
+            if diet_result.get("success"):
+                final_response = f"✅ **{diet_result.get('message', 'Operation completed successfully')}**\n\n"
+                if "result" in diet_result:
+                    # Format the result based on action type
+                    if action == "generate_diet_plan":
+                        formatted_result = format_diet_plan_result(diet_result['result'])
+                    elif action == "get_diet_recommendations":
+                        formatted_result = format_recommendations_result(diet_result['result'])
+                    elif action == "calculate_nutrition_info":
+                        formatted_result = format_nutrition_result(diet_result['result'])
+                    else:
+                        formatted_result = format_json_to_table(diet_result['result'], "Result")
+                    
+                    final_response += formatted_result
+            else:
+                final_response = f"❌ **Error**: {diet_result.get('error', 'Unknown error occurred')}"
+            
+            # Add to history
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": action_response + "\n\n" + final_response})
+            chat_history.append({"role": "assistant", "content": final_response})
+        else:
+            # For other tools, show placeholder
+            final_response = "🔄 This tool is not yet implemented in the web interface."
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": action_response + "\n\n" + final_response})
+            chat_history.append({"role": "assistant", "content": final_response})
+        
+        return history, ""
+    
+    else:
+        # Handle errors or other responses
+        error_response = f"❌ **Error**: {json.dumps(result, indent=2, ensure_ascii=False)}"
+        chat_history.append({"role": "assistant", "content": error_response})
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": error_response})
+        return history, ""
+
+def create_diet_plan_interface(age: int, sex: str, height_cm: float, weight_kg: float, 
+                              activity_level: str, goal: str, plan_type: str) -> str:
+    """Create diet plan using the interface"""
+    user_profile = {
+        "age": age,
+        "sex": sex,
+        "height_cm": height_cm,
+        "weight_kg": weight_kg,
+        "activity_level": activity_level,
+        "goal": goal,
+        "dietary_restrictions": [],
+        "allergies": [],
+        "preferences": []
+    }
+    
+    try:
+        result = generate_diet_plan(user_profile, plan_type)
+        return format_diet_plan_result(result)
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+def get_recommendations_interface(age: int, sex: str, height_cm: float, weight_kg: float, 
+                                 activity_level: str, goal: str) -> str:
+    """Get diet recommendations using the interface"""
+    user_profile = {
+        "age": age,
+        "sex": sex,
+        "height_cm": height_cm,
+        "weight_kg": weight_kg,
+        "activity_level": activity_level,
+        "goal": goal,
+        "dietary_restrictions": [],
+        "allergies": [],
+        "preferences": []
+    }
+    
+    try:
+        result = get_diet_recommendations(user_profile)
+        return format_recommendations_result(result)
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+def calculate_nutrition_interface(food_name: str, portion_grams: float) -> str:
+    """Calculate nutrition info using the interface"""
+    try:
+        result = calculate_nutrition_info(food_name, portion_grams)
+        return format_nutrition_result(result)
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(title="RAG Diet Assistant") as app:
+    gr.Markdown("# 🍽️ RAG Diet Assistant")
+    gr.Markdown("Your intelligent nutrition planning assistant powered by RAG (Retrieval-Augmented Generation)")
+    
+    with gr.Tabs():
+        # Chat Interface Tab
+        with gr.Tab("💬 Chat Assistant"):
+            gr.Markdown("Ask me anything about diet planning, nutrition, or health!")
+            
+            chatbot = gr.Chatbot(
+                label="Conversation",
+                height=500,
+                type="messages",
+                render_markdown=True
+            )
+            
+            with gr.Row():
+                msg = gr.Textbox(
+                    label="Your message",
+                    placeholder="Ask me to create a diet plan, calculate nutrition, or get recommendations...",
+                    lines=2,
+                    scale=4
+                )
+                send_btn = gr.Button("Send", variant="primary", scale=1)
+            
+            # Action buttons
+            with gr.Row():
+                clear_btn = gr.Button("Clear Chat", variant="secondary")
+                load_latest_btn = gr.Button("📄 Load Latest JSON", variant="secondary")
+                list_outputs_btn = gr.Button("📁 List All Outputs", variant="secondary")
+            
+            # Event handlers
+            msg.submit(process_user_input, [msg, chatbot], [chatbot, msg])
+            send_btn.click(process_user_input, [msg, chatbot], [chatbot, msg])
+            clear_btn.click(lambda: ([], ""), outputs=[chatbot, msg])
+            load_latest_btn.click(lambda: ([{"role": "assistant", "content": load_latest_json_output()}], ""), outputs=[chatbot, msg])
+            list_outputs_btn.click(lambda: ([{"role": "assistant", "content": list_all_json_outputs()}], ""), outputs=[chatbot, msg])
+        
+        # Diet Plan Creator Tab
+        with gr.Tab("📋 Diet Plan Creator"):
+            gr.Markdown("Create personalized diet plans based on your profile")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Personal Information")
+                    age = gr.Number(label="Age", value=30, minimum=15, maximum=100)
+                    sex = gr.Dropdown(label="Gender", choices=["male", "female"], value="male")
+                    height_cm = gr.Number(label="Height (cm)", value=175, minimum=100, maximum=250)
+                    weight_kg = gr.Number(label="Weight (kg)", value=75, minimum=30, maximum=300)
+                    
+                    gr.Markdown("### Activity & Goals")
+                    activity_level = gr.Dropdown(
+                        label="Activity Level",
+                        choices=["sedentary", "light", "moderate", "active", "very_active"],
+                        value="moderate"
+                    )
+                    goal = gr.Dropdown(
+                        label="Goal",
+                        choices=["weight_loss", "muscle_gain", "maintenance", "keto", "mediterranean"],
+                        value="weight_loss"
+                    )
+                    plan_type = gr.Dropdown(
+                        label="Plan Type",
+                        choices=["daily", "weekly"],
+                        value="daily"
+                    )
+                    
+                    create_plan_btn = gr.Button("Create Diet Plan", variant="primary")
+                
+                with gr.Column():
+                    plan_output = gr.Textbox(
+                        label="Diet Plan",
+                        lines=20,
+                        max_lines=30
+                    )
+            
+            create_plan_btn.click(
+                create_diet_plan_interface,
+                inputs=[age, sex, height_cm, weight_kg, activity_level, goal, plan_type],
+                outputs=plan_output
+            )
+        
+        # Recommendations Tab
+        with gr.Tab("📊 Diet Recommendations"):
+            gr.Markdown("Get personalized nutrition recommendations")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Personal Information")
+                    rec_age = gr.Number(label="Age", value=30, minimum=15, maximum=100)
+                    rec_sex = gr.Dropdown(label="Gender", choices=["male", "female"], value="male")
+                    rec_height_cm = gr.Number(label="Height (cm)", value=175, minimum=100, maximum=250)
+                    rec_weight_kg = gr.Number(label="Weight (kg)", value=75, minimum=30, maximum=300)
+                    
+                    gr.Markdown("### Activity & Goals")
+                    rec_activity_level = gr.Dropdown(
+                        label="Activity Level",
+                        choices=["sedentary", "light", "moderate", "active", "very_active"],
+                        value="moderate"
+                    )
+                    rec_goal = gr.Dropdown(
+                        label="Goal",
+                        choices=["weight_loss", "muscle_gain", "maintenance", "keto", "mediterranean"],
+                        value="weight_loss"
+                    )
+                    
+                    get_rec_btn = gr.Button("Get Recommendations", variant="primary")
+                
+                with gr.Column():
+                    rec_output = gr.Textbox(
+                        label="Recommendations",
+                        lines=15,
+                        max_lines=20
+                    )
+            
+            get_rec_btn.click(
+                get_recommendations_interface,
+                inputs=[rec_age, rec_sex, rec_height_cm, rec_weight_kg, rec_activity_level, rec_goal],
+                outputs=rec_output
+            )
+        
+        # Nutrition Calculator Tab
+        with gr.Tab("🧮 Nutrition Calculator"):
+            gr.Markdown("Calculate nutritional values for specific foods")
+            
+            with gr.Row():
+                with gr.Column():
+                    food_name = gr.Textbox(
+                        label="Food Name",
+                        placeholder="e.g., Chicken Breast, Apple, Brown Rice...",
+                        value="Chicken Breast"
+                    )
+                    portion_grams = gr.Number(
+                        label="Portion (grams)",
+                        value=150,
+                        minimum=1,
+                        maximum=1000
+                    )
+                    
+                    calc_nutrition_btn = gr.Button("Calculate Nutrition", variant="primary")
+                
+                with gr.Column():
+                    nutrition_output = gr.Textbox(
+                        label="Nutritional Information",
+                        lines=15,
+                        max_lines=20
+                    )
+            
+            calc_nutrition_btn.click(
+                calculate_nutrition_interface,
+                inputs=[food_name, portion_grams],
+                outputs=nutrition_output
+            )
+
+if __name__ == "__main__":
+    app.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        share=False
+    )

main3.py

@@ -0,0 +1,477 @@
+# main.py
+# Takes multi-turn chat from console → Selects most relevant tool cards with RAG →
+# Directs Groq model with single "JSON-only" contract →
+# If model args are missing, generates QUESTION in format { "final": "<which fields are needed?>" } →
+# When args are complete, returns { "action": "<tool>", "args": {...} }.
+# NOTE: Existing logic is preserved; only new tool (generate_workout_plan) is integrated.
+
+import os
+import json
+import numpy as np
+from typing import Dict, Any, List
+from sentence_transformers import SentenceTransformer
+from groq import Client   # Groq Python SDK
+from diet_tool import generate_diet_plan, get_diet_recommendations, calculate_nutrition_info
+# 1) Your Groq API key - for Hugging Face Spaces, set this as a secret
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+if not GROQ_API_KEY:
+    raise ValueError("GROQ_API_KEY environment variable is required. Please set it in your Hugging Face Space secrets.")
+client = Client(api_key=GROQ_API_KEY)
+
+# 2) Embedding model and tool cards (RAG)
+embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+
+tool_cards = [
+    {
+        "name": "one_rm_calculator",
+        "description": (
+            "Calculate 1-rep-max (1RM) from a lifted weight (kg) and reps using the "
+            "Wathan equation, and return JSON with the 1RM plus predicted weights for 1-10 reps."
+        )
+    },
+    {
+        "name": "get_user_profile",
+        "description": "Fetch the current user's profile summary."
+    },
+    {
+        "name": "analyze_exercise_video",
+        "description": "Analyze a given exercise video and return coaching feedback."
+    },
+    {
+        "name": "calculate_body_fat",
+        "description": "Calculates user's body fat percentage using U.S. Navy formula. Arguments: user_id (string), sex, height_cm, weight_kg, neck_cm, waist_cm, hip_cm."
+    },
+    {
+        "name": "upsert_profile",
+        "description": "Creates or updates user profile in database. Arguments: user_id, sex, height_cm, weight_kg, neck_cm, waist_cm, hip_cm."
+    },
+    {
+        "name": "generate_workout_plan",
+        "description": "Creates block-periodized, auto-regulated, VBT/HRV compatible, multi-disciplinary training plan (with user profile + goal + weekly days count)."
+    },
+    {
+        "name": "generate_diet_plan",
+        "description": "Creates personalized diet plan based on user profile and goals (daily/weekly plan, calorie calculation, macronutrient distribution)."
+    },
+    {
+        "name": "get_diet_recommendations",
+        "description": "Creates diet recommendations and nutrition advice for user profile (BMR, TDEE, macro targets)."
+    },
+    {
+        "name": "calculate_nutrition_info",
+        "description": "Calculates nutritional values for a specific food (calories, protein, carbs, fat, fiber)."
+    }
+]
+
+# 2.b) Tool parameter schemas (to properly direct and validate the model)
+tool_param_schemas: Dict[str, Dict[str, Any]] = {
+    "one_rm_calculator": {
+        "type": "object",
+        "properties": {
+            "weight_kg": {
+                "type": "number",
+                "description": "Weight lifted in kilograms."
+            },
+            "reps": {
+                "type": "integer",
+                "minimum": 1,
+                "maximum": 10,
+                "description": "Number of repetitions (1-10)."
+            },
+            "exercise": {                    # 🆕 nullable
+            "oneOf": [
+                {
+                    "type": "string",
+                    "enum": [
+                        "Bench Press", "Squat", "Deadlift", "Overhead Press",
+                        "Barbell Row", "Weighted Dips", "Weighted Pull Ups"
+                    ]
+                },
+                { "type": "null" }
+            ],
+            "description": (
+                "Exercise name. Leave null or omit if the user did not specify. Only Bench Press, Squat, "
+                "Deadlift, Overhead Press, Barbell Row, Weighted Dips, and Weighted Pull Ups are supported. "
+                "You can translate the user-provided exercise name if needed, e.g. Barfiks -> Weighted Pull Ups, Bench -> Bench Press."
+            )
+        },
+        },
+        "required": ["weight_kg", "reps"]
+    },
+    "get_user_profile": {
+        "type": "object",
+        "properties": {},
+        "required": []
+    },
+    "analyze_exercise_video": {
+        "type": "object",
+        "properties": {
+            "videoUrl": {"type": "string", "description": "Publicly accessible video URL"},
+            "exercise": {"type": "string", "description": "Exercise name, e.g., 'Squat'"}
+        },
+        "required": ["videoUrl", "exercise"]
+    },
+    "calculate_body_fat": {
+        "type": "object",
+        "properties": {
+            "user_id": {"type": "string", "description": "User identifier"},
+            "sex": {"type": "string"},
+            "height_cm": {"type": "number"},
+            "weight_kg": {"type": "number"},
+            "neck_cm": {"type": "number"},
+            "waist_cm": {"type": "number"},
+            "hip_cm": {"type": "number"}
+        },
+        "required": ["user_id", "height_cm", "weight_kg", "neck_cm", "waist_cm", "hip_cm", "sex"]
+    },
+    "upsert_profile": {
+        "type": "object",
+        "properties": {
+            "user_id": {"type": "string"},
+            "sex": {"type": "string"},
+            "height_cm": {"type": "number"},
+            "weight_kg": {"type": "number"},
+            "neck_cm": {"type": "number"},
+            "waist_cm": {"type": "number"},
+            "hip_cm": {"type": "number"}
+        },
+        "required": ["user_id", "sex", "height_cm", "weight_kg", "neck_cm", "waist_cm"]  # hip_cm optional
+    },
+    "generate_workout_plan": {
+        "type": "object",
+        "properties": {
+            "user_profile": {"type": "object", "description": "User profile/summary; may include injuries, recent_1RM etc."},
+            "goal": {"type": "string", "enum": ["hypertrophy", "strength", "fat_loss", "general_fitness"]},
+            "days_per_week": {"type": "integer", "minimum": 1, "maximum": 7},
+            "sport": {"type": "string",
+                      "enum": ["general", "powerlifting", "olympic_weightlifting", "crossfit",
+                               "bodybuilding", "endurance", "strongman", "calisthenics", "combat_sports"]},
+            "training_level": {"type": "string", "enum": ["novice", "intermediate", "advanced"]},
+            "sex": {"type": "string", "enum": ["male", "female"]},
+            "cycle_phase": {"type": "string", "enum": ["follicular", "luteal", "na"]},
+            "weekly_volume_pref": {"type": "string", "enum": ["low", "moderate", "high"]},
+            "block_type": {"type": "string", "enum": ["accumulation", "intensification", "peaking", "deload"]},
+            "mesocycle_length": {"type": "integer"},
+            "equipment": {"type": "array", "items": {"type": "string"}},
+            "weak_points": {"type": "array", "items": {"type": "string"}},
+            "sticking_points": {"type": "object"},
+            "auto_accessories": {"type": "boolean"},
+            "vbt_available": {"type": "boolean"},
+            "readiness_score": {"type": "number", "minimum": 0, "maximum": 10},
+            "constraints": {"type": "object"},
+            "swap_exercise_if_unavailable": {"type": "boolean"}
+        },
+        "required": ["user_profile", "goal", "days_per_week"]
+    },
+    "generate_diet_plan": {
+        "type": "object",
+        "properties": {
+            "user_profile": {
+                "type": "object",
+                "properties": {
+                    "age": {"type": "integer", "minimum": 15, "maximum": 100},
+                    "sex": {"type": "string", "enum": ["male", "female"]},
+                    "height_cm": {"type": "number", "minimum": 100, "maximum": 250},
+                    "weight_kg": {"type": "number", "minimum": 30, "maximum": 300},
+                    "activity_level": {"type": "string", "enum": ["sedentary", "light", "moderate", "active", "very_active"]},
+                    "goal": {"type": "string", "enum": ["weight_loss", "muscle_gain", "maintenance", "keto", "mediterranean"]},
+                    "dietary_restrictions": {"type": "array", "items": {"type": "string"}},
+                    "allergies": {"type": "array", "items": {"type": "string"}},
+                    "preferences": {"type": "array", "items": {"type": "string"}}
+                },
+                "required": ["age", "sex", "height_cm", "weight_kg", "activity_level", "goal"]
+            },
+            "plan_type": {"type": "string", "enum": ["daily", "weekly"], "default": "daily"}
+        },
+        "required": ["user_profile"]
+    },
+    "get_diet_recommendations": {
+        "type": "object",
+        "properties": {
+            "user_profile": {
+                "type": "object",
+                "properties": {
+                    "age": {"type": "integer", "minimum": 15, "maximum": 100},
+                    "sex": {"type": "string", "enum": ["male", "female"]},
+                    "height_cm": {"type": "number", "minimum": 100, "maximum": 250},
+                    "weight_kg": {"type": "number", "minimum": 30, "maximum": 300},
+                    "activity_level": {"type": "string", "enum": ["sedentary", "light", "moderate", "active", "very_active"]},
+                    "goal": {"type": "string", "enum": ["weight_loss", "muscle_gain", "maintenance", "keto", "mediterranean"]},
+                    "dietary_restrictions": {"type": "array", "items": {"type": "string"}},
+                    "allergies": {"type": "array", "items": {"type": "string"}},
+                    "preferences": {"type": "array", "items": {"type": "string"}}
+                },
+                "required": ["age", "sex", "height_cm", "weight_kg", "activity_level", "goal"]
+            }
+        },
+        "required": ["user_profile"]
+    },
+    "calculate_nutrition_info": {
+        "type": "object",
+        "properties": {
+            "food_name": {"type": "string", "description": "Food name"},
+            "portion_grams": {"type": "number", "minimum": 1, "maximum": 1000, "description": "Portion amount (grams)"}
+        },
+        "required": ["food_name", "portion_grams"]
+    },
+    "expand_diet_database": {
+        "type": "object",
+        "properties": {
+            "max_per_category": {"type": "integer", "minimum": 1, "maximum": 20, "description": "Maximum number of foods per category", "default": 5},
+            "output_filename": {"type": "string", "description": "Output filename (saved to outputs/ folder)", "default": "usda_foods_database.json"}
+        },
+        "required": []
+    }
+}
+
+descs = [c["description"] for c in tool_cards]
+embs = embed_model.encode(descs)
+
+# 3) Simple cosine-similarity top-K retrieval (RAG)
+def retrieve_tools(query: str, k: int = 5):
+    q_emb = embed_model.encode([query])[0]
+    sims = (embs @ q_emb) / (np.linalg.norm(embs, axis=1) * np.linalg.norm(q_emb) + 1e-10)
+    idxs = np.argsort(-sims)[:k]
+    return [tool_cards[i] for i in idxs]
+
+# 3.b) Find missing fields according to schema
+def find_missing_required(tool_name: str, args: Dict[str, Any]) -> List[str]:
+    schema = tool_param_schemas.get(tool_name)
+    if not schema:
+        return []
+    required = schema.get("required", [])
+    missing = []
+    for key in required:
+        if key not in args or args[key] in ("", None):
+            missing.append(key)
+    return missing
+
+# 3.c) Diet tool functions
+def execute_diet_tool(action: str, args: Dict[str, Any]) -> Dict[str, Any]:
+    """Execute diet tool functions and save outputs to outputs folder"""
+    try:
+        # Create outputs folder (if it doesn't exist)
+        os.makedirs("outputs", exist_ok=True)
+        
+        # Create timestamp
+        from datetime import datetime
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        if action == "generate_diet_plan":
+            user_profile = args["user_profile"]
+            plan_type = args.get("plan_type", "daily")
+            
+            result = generate_diet_plan(user_profile, plan_type)
+            
+            # Save output to file
+            filename = f"outputs/diet_plan_{plan_type}_{timestamp}.json"
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump({
+                    "action": action,
+                    "user_profile": user_profile,
+                    "plan_type": plan_type,
+                    "result": result,
+                    "timestamp": timestamp
+                }, f, ensure_ascii=False, indent=2)
+            
+            return {
+                "success": True,
+                "result": result,
+                "message": f"{plan_type.capitalize()} diet plan successfully created and saved to {filename} file."
+            }
+        
+        elif action == "get_diet_recommendations":
+            user_profile = args["user_profile"]
+            result = get_diet_recommendations(user_profile)
+            
+            # Save output to file
+            filename = f"outputs/diet_recommendations_{timestamp}.json"
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump({
+                    "action": action,
+                    "user_profile": user_profile,
+                    "result": result,
+                    "timestamp": timestamp
+                }, f, ensure_ascii=False, indent=2)
+            
+            return {
+                "success": True,
+                "result": result,
+                "message": f"Diet recommendations successfully created and saved to {filename} file."
+            }
+        
+        elif action == "calculate_nutrition_info":
+            food_name = args["food_name"]
+            portion_grams = args["portion_grams"]
+            result = calculate_nutrition_info(food_name, portion_grams)
+            
+            # Save output to file
+            filename = f"outputs/nutrition_info_{timestamp}.json"
+            with open(filename, 'w', encoding='utf-8') as f:
+                json.dump({
+                    "action": action,
+                    "food_name": food_name,
+                    "portion_grams": portion_grams,
+                    "result": result,
+                    "timestamp": timestamp
+                }, f, ensure_ascii=False, indent=2)
+            
+            return {
+                "success": True,
+                "result": result,
+                "message": f"Nutrition calculation completed and saved to {filename} file."
+            }
+        
+        elif action == "expand_diet_database":
+            max_per_category = args.get("max_per_category", 5)
+            output_filename = args.get("output_filename", "usda_foods_database.json")
+            
+            # Import and run expand_diet_data.py
+            try:
+                from expand_diet_data import expand_diet_data_from_api
+                output_path = os.path.join("outputs", output_filename)
+                expand_diet_data_from_api(output_path, max_per_category)
+                
+                return {
+                    "success": True,
+                    "result": {
+                        "max_per_category": max_per_category,
+                        "output_path": output_path
+                    },
+                    "message": f"USDA nutrition database successfully created: {output_path}"
+                }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "error": f"Error while expanding database: {str(e)}"
+                }
+        
+        else:
+            return {
+                "success": False,
+                "error": f"Unknown diet tool: {action}"
+            }
+    
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error while running diet tool: {str(e)}"
+        }
+
+# 4) RAG + Groq tool-call router (single turn)
+def _build_messages(user_query: str, cards: List[Dict[str, str]], chat_history: List[Dict[str, str]]) -> List[Dict[str, str]]:
+    # Explicitly provide tool + schema information to the model
+    tools_lines = []
+    for c in cards:
+        name = c["name"]
+        schema = tool_param_schemas.get(name, {})
+        tools_lines.append(
+            f"{name}: {c['description']}\n"
+            f"PARAMETERS(JSON Schema): {json.dumps(schema, ensure_ascii=False)}"
+        )
+    tools_block = "\n\n".join(tools_lines)
+
+    system_prompt = (
+        "You are an assistant that only returns JSON. Do not write any other explanations.\n"
+        "IF TOOL IS NEEDED: produce exactly this schema → {\"action\":\"<tool_name>\",\"args\":{...}}\n"
+        "IF TOOL IS NOT NEEDED: {\"final\":\"...\"}\n"
+        "IF ARGUMENTS ARE MISSING: never make up; {\"final\":\"<ask user for required fields in ENGLISH, short and clear>\"}\n"
+        "Do not go outside JSON, do not add text before/after.\n"
+        "Tool name must be one from the list and argument names must exactly match PARAMETER schema."
+    )
+
+    # Clean chat history to remove unsupported fields like 'metadata'
+    cleaned_history = []
+    for msg in chat_history:
+        if isinstance(msg, dict) and "role" in msg and "content" in msg:
+            cleaned_msg = {"role": msg["role"], "content": msg["content"]}
+            cleaned_history.append(cleaned_msg)
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "system", "content": tools_block},
+        *cleaned_history,  # previous turns (cleaned)
+        {"role": "user", "content": user_query},
+    ]
+    return messages
+
+def run_rag_tool_router(user_query: str, chat_history: List[Dict[str, str]]):
+    cards = retrieve_tools(user_query, k=5)
+    messages = _build_messages(user_query, cards, chat_history)
+
+    resp = client.chat.completions.create(
+        model="openai/gpt-oss-120b",
+        messages=messages,
+        max_tokens=240,
+        temperature=0.0
+    )
+    text = resp.choices[0].message.content.strip()
+    try:
+        obj = json.loads(text)
+    except json.JSONDecodeError:
+        return {"error": "invalid_json", "raw": text}
+
+    # If it's final (question/message)
+    if isinstance(obj, dict) and "final" in obj:
+        return obj
+
+    # Otherwise we expect action+args
+    if not isinstance(obj, dict) or "action" not in obj or "args" not in obj:
+        return {"error": "invalid_shape", "raw": obj}
+
+    action = obj["action"]
+    args = obj.get("args", {})
+    if not isinstance(action, str) or not isinstance(args, dict):
+        return {"error": "invalid_types", "raw": obj}
+
+    # Missing field check (additional security – model should have already asked)
+    missing = find_missing_required(action, args)
+    if missing:
+        need = ", ".join(missing)
+        return {"final": f"Please provide the following fields: {need}"}
+
+    # Here you can add type validation/type conversion if you want
+    return {"action": action, "args": args}
+
+# 5) Multi-turn chat loop
+if __name__ == "__main__":
+    chat_history: List[Dict[str, str]] = []
+    print("Multi-turn RAG+Tool Router. Leave empty line to exit.\n")
+    while True:
+        user_msg = input("Enter your prompt: ").strip()
+        if not user_msg:
+            break
+
+        result = run_rag_tool_router(user_msg, chat_history)
+
+        # Update history
+        chat_history.append({"role": "user", "content": user_msg})
+
+        # Assistant response
+        if isinstance(result, dict) and "final" in result:
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+            chat_history.append({"role": "assistant", "content": json.dumps(result, ensure_ascii=False)})
+            continue
+
+        if isinstance(result, dict) and "action" in result:
+            print(json.dumps(result, ensure_ascii=False, indent=2))
+            chat_history.append({"role": "assistant", "content": json.dumps(result, ensure_ascii=False)})
+            
+            # Diet tool check and execution
+            action = result["action"]
+            args = result.get("args", {})
+            
+            if action in ["generate_diet_plan", "get_diet_recommendations", "calculate_nutrition_info", "expand_diet_database"]:
+                diet_result = execute_diet_tool(action, args)
+                print(f"\nDiet Tool Result:")
+                print(json.dumps(diet_result, ensure_ascii=False, indent=2))
+                chat_history.append({"role": "assistant", "content": json.dumps(diet_result, ensure_ascii=False)})
+            else:
+                # Placeholder for other tools
+                print("(Implementation needed for other tools)")
+            
+            continue
+
+        # Error/raw response
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+        chat_history.append({"role": "assistant", "content": json.dumps(result, ensure_ascii=False)})

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+groq>=0.4.0
+sentence-transformers>=2.2.0
+numpy>=1.21.0
+pandas>=1.3.0
+requests>=2.25.0