Update utils/gemini_explainer.py

utils/gemini_explainer.py

@@ -1,16 +1,41 @@
+# utils/gemini_explainer.py - FIXED VERSION
+
 import google.generativeai as genai
 from typing import Dict, List, Optional
 import config
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 
 class GeminiExplainer:
     """Alternative LLM explainer using Google Gemini"""
     
     def __init__(self):
-        if config.GEMINI_API_KEY:
+        self.enabled = False
+        self.model = None
+        
+        # Check if API key exists
+        if not config.GEMINI_API_KEY:
+            logger.warning("⚠️ GEMINI_API_KEY not found in environment variables")
+            return
+        
+        # Try to initialize Gemini
+        try:
             genai.configure(api_key=config.GEMINI_API_KEY)
             self.model = genai.GenerativeModel(config.GEMINI_MODEL)
-            self.enabled = True
-        else:
+            
+            # Test the connection with a simple prompt
+            test_response = self.model.generate_content("Say 'Hello'")
+            if test_response.text:
+                self.enabled = True
+                logger.info(f"✅ Gemini explainer initialized successfully with model: {config.GEMINI_MODEL}")
+            else:
+                logger.error("❌ Gemini test failed: No response text")
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to initialize Gemini: {str(e)}")
             self.enabled = False
     
     def explain_recommendation(
@@ -27,10 +52,14 @@ class GeminiExplainer:
     ) -> str:
         """Generate explanation using Gemini"""
         
-        if not self.enabled:
-            return "Gemini explainer not configured"
+        if not self.enabled or not self.model:
+            logger.warning("⚠️ Gemini not enabled, returning fallback explanation")
+            return self._generate_fallback_explanation(
+                card, rewards, rewards_rate, merchant, category, amount
+            )
         
-        prompt = f"""You are a friendly financial advisor explaining credit card rewards to everyday consumers.
+        # Build prompt for consumer-friendly explanation
+        prompt = f"""You are a friendly financial advisor helping everyday consumers optimize their credit card rewards.
 
 Transaction Details:
 - Merchant: {merchant}
@@ -39,19 +68,69 @@ Transaction Details:
 
 Recommended Card: {card}
 Rewards Earned: ${rewards:.2f} ({rewards_rate})
-Annual Potential: ${annual_potential:.2f}/year
+Annual Potential: ${annual_potential:.2f}/year if you use this card for similar purchases
 
-Task: Explain in 2-3 simple sentences why this card is the best choice. Use friendly, conversational language.
-Focus on the tangible benefit (e.g., "That's like getting a free coffee every week!").
+Task: Explain in 2-3 simple, conversational sentences why this card is the best choice for this purchase.
+
+Guidelines:
+1. Start with the tangible benefit (e.g., "You'll earn $5.02 back on this purchase")
+2. Explain the reward rate in simple terms (avoid jargon)
+3. Add a relatable comparison (e.g., "That's like getting a free coffee!")
+4. Be encouraging and friendly
+
+{"⚠️ Important: Mention this warning - " + warnings[0] if warnings else ""}
+
+Keep it under 100 words and use everyday language."""
 
-{"Warnings to mention: " + ", ".join(warnings) if warnings else ""}
-"""
-        
         try:
-            response = self.model.generate_content(prompt)
-            return response.text
+            logger.info(f"🤖 Calling Gemini for {merchant} recommendation...")
+            
+            response = self.model.generate_content(
+                prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=0.7,
+                    max_output_tokens=200,
+                )
+            )
+            
+            if response.text:
+                logger.info(f"✅ Gemini explanation generated successfully")
+                return response.text.strip()
+            else:
+                logger.warning("⚠️ Gemini returned empty response")
+                return self._generate_fallback_explanation(
+                    card, rewards, rewards_rate, merchant, category, amount
+                )
+                
         except Exception as e:
-            return f"Gemini explanation unavailable: {str(e)}"
+            logger.error(f"❌ Gemini explanation failed: {str(e)}")
+            return self._generate_fallback_explanation(
+                card, rewards, rewards_rate, merchant, category, amount
+            )
+    
+    def _generate_fallback_explanation(
+        self,
+        card: str,
+        rewards: float,
+        rewards_rate: str,
+        merchant: str,
+        category: str,
+        amount: float
+    ) -> str:
+        """Generate rule-based explanation when Gemini is unavailable"""
+        
+        explanation = f"The **{card}** is your best choice for this {category.lower()} purchase at {merchant}. "
+        explanation += f"You'll earn **{rewards_rate}**, which gives you **${rewards:.2f}** back on this transaction. "
+        
+        # Add relatable comparison
+        if rewards >= 5:
+            explanation += "That's like getting a free lunch! 🍔"
+        elif rewards >= 3:
+            explanation += "That's like getting a free coffee! ☕"
+        else:
+            explanation += "Every bit of savings counts! 💰"
+        
+        return explanation
     
     def generate_spending_insights(
         self,
@@ -64,10 +143,12 @@ Focus on the tangible benefit (e.g., "That's like getting a free coffee every we
     ) -> str:
         """Generate personalized insights using Gemini"""
         
-        if not self.enabled:
-            return "Gemini insights not configured"
+        if not self.enabled or not self.model:
+            return self._generate_fallback_insights(
+                total_spending, total_rewards, optimization_score
+            )
         
-        prompt = f"""You are a financial coach reviewing a user's credit card rewards performance.
+        prompt = f"""You are a personal finance coach reviewing a user's credit card rewards performance.
 
 User Stats:
 - Total Spending: ${total_spending:.2f}
@@ -77,15 +158,70 @@ User Stats:
 - Top Categories: {', '.join([c.get('category', 'Unknown') for c in top_categories[:3]])}
 
 Task: Provide 3 actionable insights in a friendly, motivating tone. Each insight should be 1 sentence.
-Focus on what they're doing well and one improvement opportunity.
-"""
-        
+
+Guidelines:
+1. Start with praise for what they're doing well
+2. Identify their biggest opportunity (highest spending category)
+3. Give one specific, actionable tip to improve their score
+4. Use emojis and be encouraging!
+
+Keep it under 120 words."""
+
         try:
-            response = self.model.generate_content(prompt)
-            return response.text
+            response = self.model.generate_content(
+                prompt,
+                generation_config=genai.types.GenerationConfig(
+                    temperature=0.8,
+                    max_output_tokens=200,
+                )
+            )
+            
+            if response.text:
+                return response.text.strip()
+            else:
+                return self._generate_fallback_insights(
+                    total_spending, total_rewards, optimization_score
+                )
+                
         except Exception as e:
-            return f"Gemini insights unavailable: {str(e)}"
+            logger.error(f"❌ Gemini insights generation failed: {str(e)}")
+            return self._generate_fallback_insights(
+                total_spending, total_rewards, optimization_score
+            )
+    
+    def _generate_fallback_insights(
+        self,
+        total_spending: float,
+        total_rewards: float,
+        optimization_score: int
+    ) -> str:
+        """Generate rule-based insights when Gemini unavailable"""
+        
+        rewards_rate = (total_rewards / total_spending * 100) if total_spending > 0 else 0
+        
+        insights = f"You're earning **${total_rewards:.2f}** in rewards on **${total_spending:.2f}** of spending "
+        insights += f"(**{rewards_rate:.1f}%** effective rate). "
+        
+        if optimization_score >= 80:
+            insights += "🌟 **Excellent optimization!** You're maximizing your rewards effectively. "
+        elif optimization_score >= 60:
+            insights += "👍 **Good progress!** Consider using our recommendations more consistently. "
+        else:
+            insights += "💡 **Room for improvement!** Follow our card suggestions to boost your rewards. "
+        
+        insights += "Keep tracking your spending to identify new optimization opportunities."
+        
+        return insights
+
+
+# Singleton instance
+_gemini_explainer = None
 
-def get_gemini_explainer():
-    """Factory function to get Gemini explainer"""
-    return GeminiExplainer()
+def get_gemini_explainer() -> GeminiExplainer:
+    """Get or create singleton Gemini explainer instance"""
+    global _gemini_explainer
+    
+    if _gemini_explainer is None:
+        _gemini_explainer = GeminiExplainer()
+    
+    return _gemini_explainer