Update app.py

app.py

@@ -1,191 +1,250 @@
-"""
-RAG Diet Planning Application for Hugging Face Spaces
-This application provides AI-powered diet planning with nutrition analysis.
-"""
-
 import gradio as gr
 import json
 import os
-import glob
+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
 
+# Ensure outputs directory exists
+os.makedirs("outputs", exist_ok=True)
+
+# Global chat history
+chat_history = []
+
 def format_json_to_table(json_data: Any, title: str = "") -> str:
-    """Convert JSON data to markdown table format"""
+    """Convert JSON data to a formatted table string"""
     if not json_data:
-        return "No data available"
+        return ""
     
-    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 f"**{title}**\n\n{str(json_data)}"
+    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 markdown table"""
+    """Format dictionary as a table"""
     if not data:
-        return f"**{title}**\n\nNo data available"
+        return ""
     
-    formatted = f"**{title}**\n\n" if title else ""
+    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()):
-        formatted += "| Key | Value |\n|-----|-------|\n"
+        result += "| Key | Value |\n"
+        result += "|-----|-------|\n"
         for key, value in data.items():
-            formatted += f"| {key} | {value} |\n"
+            result += f"| **{key}** | {value} |\n"
     else:
         # Complex nested structure
         for key, value in data.items():
-            if isinstance(value, (dict, list)):
-                formatted += f"\n### {key}\n"
-                formatted += format_json_to_table(value)
+            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:
-                formatted += f"**{key}**: {value}\n"
+                result += f"**{key}**: {value}\n"
     
-    return formatted
+    return result
 
 def format_list_to_table(data: list, title: str = "") -> str:
-    """Format list as markdown table"""
+    """Format list as a table"""
     if not data:
-        return f"**{title}**\n\nNo data available"
+        return ""
     
-    formatted = f"**{title}**\n\n" if title else ""
+    result = f"## {title}\n\n" if title else ""
     
-    if isinstance(data[0], dict):
-        # List of dictionaries - create table
-        keys = list(data[0].keys())
-        formatted += "| " + " | ".join(keys) + " |\n"
-        formatted += "|" + "|".join(["-----"] * len(keys)) + "|\n"
-        
+    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:
-            row = []
-            for key in keys:
-                value = item.get(key, "")
-                if isinstance(value, (dict, list)):
-                    value = str(value)[:50] + "..." if len(str(value)) > 50 else str(value)
-                row.append(str(value))
-            formatted += "| " + " | ".join(row) + " |\n"
+            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
-        formatted += "| Item |\n|------|\n"
-        for item in data:
-            formatted += f"| {item} |\n"
+        for i, item in enumerate(data):
+            result += f"{i+1}. {item}\n"
     
-    return formatted
+    return result
 
 def format_diet_plan_result(result: dict) -> str:
     """Format diet plan result specifically"""
-    if not result:
-        return "No diet plan data available"
+    if not result or "error" in result:
+        return f"❌ Error: {result.get('error', 'Unknown error')}"
     
-    formatted = "# 🍽️ Diet Plan Results\n\n"
+    formatted = "## 🍽️ Diet Plan\n\n"
     
-    # Weekly summary
-    if "weekly_summary" in result:
-        summary = result["weekly_summary"]
-        formatted += "## 📊 Weekly Summary\n\n"
-        formatted += "| Day | Calories | Protein | Carbs | Fat | Fiber |\n"
-        formatted += "|-----|----------|---------|-------|-----|-------|\n"
-        
-        for day, data in summary.items():
-            formatted += f"| {day} | {data.get('calories', 0)} | {data.get('protein', 0)}g | {data.get('carbs', 0)}g | {data.get('fat', 0)}g | {data.get('fiber', 0)}g |\n"
+    if "plan_type" in result:
+        formatted += f"**Plan Type**: {result['plan_type']}\n\n"
     
-    # Detailed meals for all 7 days
-    if "plans" in result:
-        formatted += "\n## 🍽️ Detailed Meals (All 7 Days)\n\n"
+    if "plan" in result:
+        plan = result["plan"]
         
-        for i, plan in enumerate(result["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", {})
+        # 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"
                 
-                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"
+                # 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
-                foods = meal.get("foods", [])
-                if foods:
-                    formatted += "  - Foods: "
-                    food_names = [food.get("name", "Unknown") for food in foods[:3]]
-                    formatted += ", ".join(food_names)
-                    if len(foods) > 3:
-                        formatted += f" +{len(foods)-3} more"
+                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"
-                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):  # Show all 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"
     
     return formatted
 
 def format_recommendations_result(result: dict) -> str:
-    """Format diet recommendations result"""
-    if not result:
-        return "No recommendations data available"
+    """Format recommendations result specifically"""
+    if not result or "error" in result:
+        return f"❌ Error: {result.get('error', 'Unknown error')}"
     
-    formatted = "# 🎯 Diet Recommendations\n\n"
+    formatted = "## �� Diet Recommendations\n\n"
     
-    # BMR and TDEE
+    # Basic metrics
     if "bmr" in result:
-        formatted += f"**BMR (Basal Metabolic Rate)**: {result['bmr']:.0f} calories/day\n"
+        formatted += f"**BMR (Basal Metabolic Rate)**: {result['bmr']} kcal/day\n"
     if "tdee" in result:
-        formatted += f"**TDEE (Total Daily Energy Expenditure)**: {result['tdee']:.0f} calories/day\n"
+        formatted += f"**TDEE (Total Daily Energy Expenditure)**: {result['tdee']} kcal/day\n"
     if "target_calories" in result:
-        formatted += f"**Target Calories**: {result['target_calories']:.0f} calories/day\n\n"
-    
-    # Macro distribution
-    if "macro_distribution" in result:
-        macros = result["macro_distribution"]
-        formatted += "## 📊 Macro Distribution\n\n"
-        formatted += "| Nutrient | Grams | Calories | Percentage |\n"
-        formatted += "|----------|-------|----------|------------|\n"
-        
-        for macro, data in macros.items():
-            formatted += f"| {macro.title()} | {data.get('grams', 0):.1f}g | {data.get('calories', 0):.0f} | {data.get('percentage', 0):.1f}% |\n"
+        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:
-        formatted += "\n## 💡 Recommendations\n\n"
-        for i, rec in enumerate(result["recommendations"], 1):
-            formatted += f"{i}. {rec}\n"
+        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"""
-    if not result:
-        return "No nutrition data available"
-    
-    formatted = "# 🥗 Nutrition Information\n\n"
-    
-    # Main nutrition table
-    if "nutrition" in result:
-        nutrition = result["nutrition"]
-        formatted += "## 📊 Nutrition Facts\n\n"
-        formatted += "| Nutrient | Amount | Unit |\n"
-        formatted += "|----------|--------|------|\n"
-        
-        for nutrient, data in nutrition.items():
-            if isinstance(data, dict) and "amount" in data:
-                formatted += f"| {nutrient.title()} | {data['amount']} | {data.get('unit', '')} |\n"
-            else:
-                formatted += f"| {nutrient.title()} | {data} | |\n"
+    """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:
-        formatted += "\n## 🧪 Vitamins\n\n"
-        for vitamin, amount in result["vitamins"].items():
-            formatted += f"- **{vitamin}**: {amount}\n"
+    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:
-        formatted += "\n## ⚡ Minerals\n\n"
-        for mineral, amount in result["minerals"].items():
-            formatted += f"- **{mineral}**: {amount}\n"
+    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
 
@@ -213,19 +272,122 @@ def load_latest_json_output() -> str:
         # Format based on file type
         if "diet_plan" in filename:
             if "weekly" in filename:
-                return format_diet_plan_result(data)
+                return format_weekly_diet_plan(data, filename)
             else:
-                return format_nutrition_result(data)
+                return format_daily_diet_plan(data, filename)
         elif "recommendations" in filename:
-            return format_recommendations_result(data)
+            return format_recommendations_result(data, filename)
+        elif "nutrition" in filename:
+            return format_nutrition_result(data, filename)
         else:
-            return format_json_to_table(data, f"📄 {filename}")
-    
+            return format_json_data_to_table(data, f"Latest Output: {filename}")
+            
     except Exception as e:
-        return f"❌ Error loading file: {str(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_outputs() -> str:
-    """List all JSON output files"""
+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"
@@ -234,26 +396,31 @@ def list_all_outputs() -> str:
     if not json_files:
         return "❌ No JSON files found in outputs directory"
     
-    formatted = "# 📁 All Output Files\n\n"
-    formatted += "| File | Size | Modified | Type |\n"
-    formatted += "|------|------|----------|------|\n"
+    # 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 sorted(json_files, key=os.path.getmtime, reverse=True):
+    for file_path in json_files:
         filename = os.path.basename(file_path)
-        size = os.path.getsize(file_path)
-        modified = os.path.getmtime(file_path)
+        file_type = "Unknown"
         
-        # Determine file type
         if "diet_plan_weekly" in filename:
-            file_type = "📅 Weekly Diet Plan"
+            file_type = "Weekly Diet Plan"
         elif "diet_plan_daily" in filename:
-            file_type = "📅 Daily Diet Plan"
+            file_type = "Daily Diet Plan"
         elif "recommendations" in filename:
-            file_type = "💡 Recommendations"
-        else:
-            file_type = "📄 Other"
+            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} | {size:,} bytes | {modified} | {file_type} |\n"
+        formatted += f"| {filename} | {file_type} | {file_size:,} bytes | {mod_date} |\n"
     
     return formatted
 
@@ -261,13 +428,13 @@ 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:
@@ -276,18 +443,19 @@ def extract_and_format_json_in_text(text: str) -> str:
             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
@@ -296,132 +464,314 @@ def extract_and_format_json_in_text(text: str) -> str:
                 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:
-    """Helper function to format JSON data as table"""
+    """Format JSON data to a table string"""
     if isinstance(json_data, dict):
-        if "action" in json_data:
-            # Tool action response
-            action = json_data["action"]
-            args = json_data.get("args", {})
-            return f"**🔧 Tool Action**: {action}\n\n**Arguments**:\n{format_dict_to_table(args)}"
-        elif "final" in json_data:
-            # Final response
-            return f"**💬 Response**: {json_data['final']}"
-        else:
-            return format_dict_to_table(json_data)
+        return format_dict_to_table(json_data, "Data")
     elif isinstance(json_data, list):
-        return format_list_to_table(json_data)
+        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 and return response"""
+    """Process user input through RAG system"""
+    global chat_history
+    
     if not user_input.strip():
         return history, ""
     
-    try:
-        # Convert Gradio history format to RAG format
-        rag_history = []
-        for msg in history:
-            if isinstance(msg, dict):
-                rag_history.append({
-                    "role": msg.get("role", "user"),
-                    "content": msg.get("content", "")
-                })
-            else:
-                # Handle tuple format
-                rag_history.append({
-                    "role": "user" if len(msg) == 1 else msg[0],
-                    "content": msg[1] if len(msg) > 1 else msg[0]
-                })
-        
-        # Get response from RAG system
-        result = run_rag_tool_router(user_input, rag_history)
-        
-        # Format the response
-        if result.get("action"):
-            action_response = f"🔧 **Tool Used**: {result['action']}\n\n"
-            if result.get("args"):
-                action_response += f"**Arguments**:\n{format_dict_to_table(result['args'])}\n\n"
-            if result.get("result"):
-                action_response += f"**Result**:\n{result['result']}"
-            final_response = action_response
+    # Convert Gradio history format to our format
+    rag_history = []
+    for msg in history:
+        if isinstance(msg, dict):
+            rag_history.append(msg)
         else:
-            final_response = result.get("final", "No response generated")
-        
+            # 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(final_response)
-        
-        # Update history
+        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, ""
     
-    except Exception as e:
-        error_msg = f"❌ Error: {str(e)}"
+    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_msg})
+        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
-def create_interface():
-    with gr.Blocks(title="🍽️ AI Diet Planner", theme=gr.themes.Soft()) as app:
-        gr.Markdown("# 🍽️ AI Diet Planner & Nutrition Assistant")
-        gr.Markdown("Ask me to create personalized diet plans, calculate nutrition information, or get dietary recommendations!")
-        
-        # Chat interface
-        chatbot = gr.Chatbot(
-            label="Conversation",
-            height=500,
-            type="messages",
-            render_markdown=True
-        )
-        
-        # Input area
-        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
+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
             )
-            send_btn = gr.Button("Send", variant="primary", scale=1)
+            
+            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])
         
-        # 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")
+        # 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
+            )
         
-        # 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(load_latest_json_output, outputs=chatbot)
-        list_outputs_btn.click(list_all_outputs, outputs=chatbot)
+        # 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
+            )
         
-        # Examples
-        gr.Examples(
-            examples=[
-                "Create a weekly diet plan for a 25-year-old male, 70kg, 175cm, moderate activity",
-                "Calculate nutrition for 200g chicken breast and 150g rice",
-                "Get diet recommendations for weight loss",
-                "Create a vegetarian meal plan for 7 days"
-            ],
-            inputs=msg
-        )
-    
+        # 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
+            )
+
+def create_gradio_interface():
+    """Create and return the Gradio interface for Hugging Face Spaces"""
     return app
 
-# Create and launch the app
 if __name__ == "__main__":
-    app = create_interface()
+    # For local development
     app.launch(
-        server_name="0.0.0.0",
+        server_name="127.0.0.1",
         server_port=7860,
         share=False
     )