Update app.py

app.py

@@ -1,6 +1,56 @@
 """
 Beautiful Gradio interface for credit card recommendations
 """
+
+# Add after imports, before client initialization
+from typing import Dict, Any
+import traceback  
+
+
+def safe_get(data: Dict, key: str, default: Any = None) -> Any:
+    """Safely get value from dictionary with fallback"""
+    try:
+        return data.get(key, default)
+    except:
+        return default
+
+
+def normalize_recommendation_data(data: Dict) -> Dict:
+    """Normalize API response to ensure all required fields exist"""
+    
+    # Extract or compute rewards_earned
+    rewards_earned = safe_get(data, 'rewards_earned')
+    if rewards_earned is None:
+        amount = safe_get(data, 'amount', 0)
+        rewards_rate = safe_get(data, 'rewards_rate', '0x points')
+        
+        try:
+            if 'x' in str(rewards_rate):
+                multiplier = float(rewards_rate.split('x')[0])
+                rewards_earned = amount * (multiplier / 100)
+            elif '%' in str(rewards_rate):
+                multiplier = float(rewards_rate.replace('%', '').split()[0])
+                rewards_earned = amount * (multiplier / 100)
+            else:
+                rewards_earned = 0
+        except:
+            rewards_earned = 0
+    
+    return {
+        'recommended_card': safe_get(data, 'recommended_card', 'Unknown Card'),
+        'rewards_earned': round(float(rewards_earned), 2),
+        'rewards_rate': safe_get(data, 'rewards_rate', 'N/A'),
+        'merchant': safe_get(data, 'merchant', 'Unknown Merchant'),
+        'category': safe_get(data, 'category', 'Unknown'),
+        'amount': float(safe_get(data, 'amount', 0)),
+        'annual_potential': float(safe_get(data, 'annual_potential', rewards_earned * 12)),
+        'optimization_score': int(safe_get(data, 'optimization_score', 75)),
+        'reasoning': safe_get(data, 'reasoning', 'Optimal choice for this category'),
+        'warnings': safe_get(data, 'warnings', []),
+        'alternatives': safe_get(data, 'alternatives', []),
+        'mock_data': safe_get(data, 'mock_data', False)
+    }
+    
 from datetime import date
 from typing import Optional, Tuple, List, Dict, Any
 import gradio as gr
@@ -100,6 +150,13 @@ def get_recommendation(
 def get_recommendation_with_ai(user_id, merchant, category, amount):
     """Get card recommendation with LLM-powered explanation"""
     
+    # Validate inputs
+    if not merchant or not merchant.strip():
+        return "❌ Please enter a merchant name.", None
+    
+    if amount <= 0:
+        return "❌ Please enter a valid amount greater than $0.", None
+    
     try:
         # Get base recommendation from orchestrator
         result = client.get_recommendation(
@@ -110,9 +167,11 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
         )
         
         if not result.get('success'):
-            return f"❌ Error: {result.get('error', 'Unknown error')}", None
+            error_msg = result.get('error', 'Unknown error')
+            return f"❌ Error: {error_msg}", None
         
-        data = result['data']
+        # Normalize the data to ensure all fields exist
+        data = normalize_recommendation_data(result.get('data', {}))
         
         # Generate LLM explanation if enabled
         ai_explanation = ""
@@ -125,9 +184,9 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
                     merchant=merchant,
                     category=category,
                     amount=float(amount),
-                    warnings=data.get('warnings'),
-                    annual_potential=data.get('annual_potential'),
-                    alternatives=data.get('alternatives', [])
+                    warnings=data['warnings'] if data['warnings'] else None,
+                    annual_potential=data['annual_potential'],
+                    alternatives=data['alternatives']
                 )
             except Exception as e:
                 print(f"LLM explanation failed: {e}")
@@ -135,12 +194,19 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
         
         # Format output with AI explanation
         output = f"""
-## 🎯 Recommendation for ${amount} at {merchant}
+## 🎯 Recommendation for ${amount:.2f} at {merchant}
 
 ### 💳 Best Card: **{data['recommended_card']}**
 
 **Rewards Earned:** ${data['rewards_earned']:.2f} ({data['rewards_rate']})
 
+"""
+        
+        # Add mock data indicator
+        if data.get('mock_data'):
+            output += """
+> ⚠️ **Demo Mode:** Using sample data. Connect to orchestrator for real recommendations.
+
 """
         
         # Add AI explanation if available
@@ -158,32 +224,89 @@ def get_recommendation_with_ai(user_id, merchant, category, amount):
         output += f"""
 ### 📊 Breakdown
 
-- **Category:** {category}
-- **Annual Potential:** ${data.get('annual_potential', 0):.2f}
-- **Optimization Score:** {data.get('optimization_score', 'N/A')}/100
+- **Category:** {data['category']}
+- **Merchant:** {data['merchant']}
+- **Annual Potential:** ${data['annual_potential']:.2f}
+- **Optimization Score:** {data['optimization_score']}/100
 """
         
         # Add warnings
-        if data.get('warnings'):
-            output += "\n\n### ⚠️ Warnings\n\n"
+        if data['warnings']:
+            output += "\n\n### ⚠️ Important Warnings\n\n"
             for warning in data['warnings']:
                 output += f"- {warning}\n"
         
         # Add alternatives
-        if data.get('alternatives'):
+        if data['alternatives']:
             output += "\n\n### 🔄 Alternative Options\n\n"
             for alt in data['alternatives'][:3]:
-                output += f"- **{alt['card']}:** ${alt['rewards']:.2f} ({alt['rate']})\n"
+                alt_rewards = safe_get(alt, 'rewards', 0)
+                alt_rate = safe_get(alt, 'rate', 'N/A')
+                alt_card = safe_get(alt, 'card', 'Unknown')
+                output += f"- **{alt_card}:** ${alt_rewards:.2f} ({alt_rate})\n"
         
-        # Create visualization (your existing chart code)
+        # Create visualization
         chart = create_rewards_comparison_chart(data)
         
         return output, chart
         
     except Exception as e:
-        return f"❌ Error: {str(e)}", None
-
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Recommendation error: {error_details}")
+        return f"❌ Error: {str(e)}\n\nPlease check your API connection or try again.", None
 
+def create_rewards_comparison_chart(data: Dict) -> go.Figure:
+    """Create rewards comparison chart"""
+    
+    try:
+        # Prepare data for chart
+        cards = [data['recommended_card']]
+        rewards = [data['rewards_earned']]
+        
+        # Add alternatives
+        for alt in data.get('alternatives', [])[:3]:
+            cards.append(safe_get(alt, 'card', 'Unknown'))
+            rewards.append(float(safe_get(alt, 'rewards', 0)))
+        
+        # Create bar chart
+        fig = go.Figure(data=[
+            go.Bar(
+                x=cards,
+                y=rewards,
+                marker=dict(
+                    color=['#667eea'] + ['#a0aec0'] * (len(cards) - 1),
+                    line=dict(color='white', width=2)
+                ),
+                text=[f'${r:.2f}' for r in rewards],
+                textposition='outside',
+            )
+        ])
+        
+        fig.update_layout(
+            title='Rewards Comparison',
+            xaxis_title='Credit Card',
+            yaxis_title='Rewards Earned ($)',
+            template='plotly_white',
+            height=400,
+            showlegend=False,
+            margin=dict(t=50, b=50, l=50, r=50)
+        )
+        
+        return fig
+        
+    except Exception as e:
+        print(f"Chart creation error: {e}")
+        # Return empty chart with error message
+        fig = go.Figure()
+        fig.add_annotation(
+            text=f"Error creating chart: {str(e)}",
+            xref="paper", yref="paper",
+            x=0.5, y=0.5, showarrow=False,
+            font=dict(size=14, color="red")
+        )
+        return fig
+        
 def get_analytics_with_insights(user_id):
     """Get analytics with LLM-generated insights"""
     
@@ -747,26 +870,38 @@ Get AI-powered credit card recommendations that maximize your rewards based on:
             )
             
             def respond(message, chat_history, user_id):
-                """Handle chat responses"""
+                """Handle chat responses with error handling"""
                 if not message.strip():
                     return "", chat_history
                 
-                # Get user context
+                # Get user context with error handling
+                user_context = {}
                 try:
                     analytics = client.get_user_analytics(user_id)
+                    if analytics.get('success'):
+                        data = analytics.get('data', {})
+                        user_context = {
+                            'cards': safe_get(data, 'cards', ['Amex Gold', 'Chase Sapphire Reserve']),
+                            'monthly_spending': safe_get(data, 'total_spending', 0),
+                            'top_category': safe_get(data, 'top_category', 'Groceries')
+                        }
+                except Exception as e:
+                    print(f"Error getting user context: {e}")
                     user_context = {
-                        'cards': analytics.get('data', {}).get('cards', []),
-                        'monthly_spending': analytics.get('data', {}).get('total_spending', 0),
-                        'top_category': analytics.get('data', {}).get('top_category', 'Unknown')
+                        'cards': ['Amex Gold', 'Chase Sapphire Reserve'],
+                        'monthly_spending': 3450.75,
+                        'top_category': 'Groceries'
                     }
-                except:
-                    user_context = {}
                 
-                # Generate AI response
-                if config.LLM_ENABLED:
-                    bot_response = llm.chat_response(message, user_context, chat_history)
-                else:
-                    bot_response = "I'm currently in fallback mode. Please ask specific questions about your cards or transactions."
+                # Generate AI response with error handling
+                try:
+                    if config.LLM_ENABLED:
+                        bot_response = llm.chat_response(message, user_context, chat_history)
+                    else:
+                        bot_response = "I'm currently in fallback mode. Ask me about specific cards or categories!"
+                except Exception as e:
+                    print(f"Chat error: {e}")
+                    bot_response = f"I encountered an error. Please try asking your question differently."
                 
                 chat_history.append((message, bot_response))
                 return "", chat_history