Update app.py

app.py

@@ -7,7 +7,7 @@ from typing import Dict, List, Tuple, Optional
 
 # Configure logging
 logging.basicConfig(
-    level=logging.DEBUG,
+    level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
 )
 logger = logging.getLogger(__name__)
@@ -15,297 +15,95 @@ logger = logging.getLogger(__name__)
 app = Flask(__name__, static_folder='static')
 CORS(app)
 
-# Configuration
-MODEL_API_URL = "https://api-inference.huggingface.co/models/HuggingFaceH4/zephyr-7b-beta"
-API_KEY = os.getenv("HF_API_KEY")
+# Hugging Face Space Configuration
+HF_API_URL = os.getenv("HF_API_URL", "https://api-inference.huggingface.co/models/HuggingFaceH4/zephyr-7b-beta")
+HF_TOKEN = os.getenv("HF_TOKEN")  # Will use Spaces secrets
 FALLBACK_ENABLED = True
-MODEL_TIMEOUT = 15  # seconds
-MODEL_MAX_TOKENS = 300
-
-# Type aliases
-QuickReply = Dict[str, str]
-CategoryResponses = Dict[str, Dict[str, Dict[str, str]]]
+MODEL_TIMEOUT = 10  # seconds
 
 class RupeiaChatbot:
-    """Main chatbot class handling both model and fallback responses"""
-    
     def __init__(self):
-        self.fallback_responses = self._load_fallback_responses()
-        self.category_quick_replies = self._load_category_quick_replies()
-        
-    @staticmethod
-    def _load_fallback_responses() -> CategoryResponses:
-        """Load all predefined fallback responses"""
+        self.fallback_responses = self._load_responses()
+        self.quick_replies = self._load_quick_replies()
+
+    def _load_responses(self) -> Dict[str, Dict[str, str]]:
+        """Load all predefined responses"""
         return {
-            "investment": {
-                "sip_start_detailed": {
-                    "response": "To start a new SIP with Rupeia, log in to your account, navigate to 'Investments' > 'SIP', select a fund like DSP ELSS Tax Saver Fund, and set your investment amount and frequency. The minimum investment amount is ₹500 per month.",
-                    "quick_replies": [
-                        {"title": "SIP vs Lumpsum", "value": "What's the difference between SIP and Lumpsum?"},
-                        {"title": "Pause SIP", "value": "Can I pause my SIP for a few months?"}
-                    ]
-                },
-                "sip_lumpsum_diff_detailed": {
-                    "response": "SIP involves regular, fixed investments (e.g., monthly), ideal for disciplined investing, while Lumpsum is a one-time investment, suited for surplus funds.",
-                    "quick_replies": [
-                        {"title": "Start SIP", "value": "How do I start an SIP with Rupeia?"},
-                        {"title": "Wealth+ Features", "value": "What's Wealth+ and how do I get it?"}
-                    ]
-                }
-            },
-            "goals": {
-                "create_goal_detailed": {
-                    "response": "To create a financial goal like saving for a wedding, go to 'Goals' > 'Create Goal', select the goal type, enter your budget and duration, and Rupeia will suggest an investment plan.",
-                    "quick_replies": [
-                        {"title": "Change Goal Budget", "value": "Can I change my goal budget later?"},
-                        {"title": "Track Goals", "value": "What goals can I track on Rupeia?"}
-                    ]
-                }
+            "sip": {
+                "response": "To start an SIP with Rupeia: 1) Login 2) Go to Investments 3) Select SIP option 4) Choose fund and amount. Minimum ₹500/month.",
+                "quick_replies": ["sip vs lumpsum", "pause sip"]
             },
-            "benefits": {
-                "monitoring_24_7_detailed": {
-                    "response": "Rupeia's 24/7 monitoring uses AI to track market trends and adjust your portfolio for steady growth.",
-                    "quick_replies": [
-                        {"title": "Personalized Suggestions", "value": "How are investment suggestions personalized?"},
-                        {"title": "Loss Prevention", "value": "How does Loss Prevention work?"}
-                    ]
-                }
-            },
-            "gadgets": {
-                "save_ipad_detailed": {
-                    "response": "To save for an iPad, create a goal in 'Goals' > 'Gadgets', set your budget and timeline, and link it to an SIP.",
-                    "quick_replies": [
-                        {"title": "Samsung Tablets", "value": "Which Samsung tablets fit my budget?"},
-                        {"title": "Compare Phones", "value": "How do I compare Apple and Samsung phones?"}
-                    ]
-                }
-            },
-            "news_blogs": {
-                "find_news_detailed": {
-                    "response": "Find financial news in 'News & Blogs' > 'Financial News'. You can bookmark articles to save them.",
-                    "quick_replies": [
-                        {"title": "Save Blogs", "value": "Can I save blogs?"},
-                        {"title": "Gadget Blogs", "value": "How do I find blogs on gadgets?"}
-                    ]
-                }
-            }
-        }
-    
-    @staticmethod
-    def _load_category_quick_replies() -> Dict[str, List[QuickReply]]:
-        """Load quick replies organized by category"""
-        return {
-            "investment": [
-                {"title": "Start SIP", "value": "How do I start an SIP with Rupeia?"},
-                {"title": "SIP vs Lumpsum", "value": "What's the difference between SIP and Lumpsum?"},
-                {"title": "Wealth+ Features", "value": "What's Wealth+ and how do I get it?"}
-            ],
-            "goals": [
-                {"title": "Set Car Goal", "value": "How do I set a goal to save for a car?"},
-                {"title": "Change Goal Budget", "value": "Can I change my goal budget later?"}
-            ],
-            "benefits": [
-                {"title": "24/7 Monitoring", "value": "What's 24/7 monitoring on my portfolio?"},
-                {"title": "Personalized Suggestions", "value": "How are investment suggestions personalized?"}
-            ],
-            "gadgets": [
-                {"title": "Save for iPad", "value": "Can I save for an iPad with SIP?"},
-                {"title": "Compare Phones", "value": "How do I compare Apple and Samsung phones?"}
-            ],
-            "news_blogs": [
-                {"title": "Latest News", "value": "Where's the latest financial news?"},
-                {"title": "Save Blogs", "value": "Can I save blogs?"}
-            ]
+            # Add other responses similarly
         }
-    
-    def match_category(self, message: str) -> Optional[str]:
-        """Determine which category the user's message belongs to"""
-        message = message.lower()
-        category_keywords = {
-            "investment": ["sip", "lumpsum", "portfolio", "wealth+"],
-            "goals": ["goal", "budget", "save for"],
-            "benefits": ["monitoring", "personalized", "loss prevention"],
-            "gadgets": ["ipad", "phone", "laptop", "gadget"],
-            "news_blogs": ["news", "blog", "article"]
-        }
-        
-        for category, keywords in category_keywords.items():
-            if any(keyword in message for keyword in keywords):
-                return category
-        return None
-    
-    def get_fallback_response(self, message: str) -> Tuple[str, List[QuickReply]]:
-        """Get the most appropriate predefined response"""
+
+    def get_fallback(self, message: str) -> Tuple[str, List[str]]:
+        """Get fallback response"""
         message = message.lower()
-        
-        # Try exact matches first
-        for category, items in self.fallback_responses.items():
-            for key, data in items.items():
-                keywords = key.split('_') + [category]
-                if any(keyword in message for keyword in keywords):
-                    return data["response"], data["quick_replies"]
-        
-        # Then try category-based quick replies
-        category = self.match_category(message)
-        if category:
-            return (
-                f"I can help with {category} related questions. Please choose an option:",
-                self.category_quick_replies.get(category, [])
-            )
-        
-        # Final fallback
-        return (
-            "I'm here to help with your financial questions. Could you be more specific?",
-            [
-                {"title": "Investments", "value": "Tell me about investment options"},
-                {"title": "Savings Goals", "value": "How to set savings goals?"}
-            ]
-        )
-    
-    def generate_model_response(self, message: str) -> Optional[str]:
-        """Generate response using Hugging Face model"""
-        if not API_KEY:
-            logger.warning("No Hugging Face API key configured")
+        for intent, data in self.fallback_responses.items():
+            if intent in message:
+                return data["response"], data["quick_replies"]
+        return "I can help with investments, goals, and more. Please ask clearly.", ["start sip", "set goal"]
+
+    def query_model(self, message: str) -> Optional[str]:
+        """Query HF model with error handling"""
+        if not HF_TOKEN:
             return None
 
-        prompt = f"""<|system|>
-        You are Rupeia, a helpful AI financial assistant for a platform called Rupeia.
-        Provide concise, accurate responses to financial questions.
-        Always respond in a professional but friendly tone.
-        If asked about non-financial topics, politely redirect to financial matters.
-        </s>
-        <|user|>
-        {message}
-        </s>
-        <|assistant|>
-        """
-        
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        payload = {
+            "inputs": f"""<|system|>
+            You are Rupeia, a financial assistant. Respond concisely to:
+            {message}</s><|assistant|>""",
+            "parameters": {"max_new_tokens": 250}
+        }
+
         try:
-            headers = {
-                "Authorization": f"Bearer {API_KEY}",
-                "Content-Type": "application/json"
-            }
-            payload = {
-                "inputs": prompt,
-                "parameters": {
-                    "max_new_tokens": MODEL_MAX_TOKENS,
-                    "temperature": 0.7,
-                    "top_p": 0.9,
-                    "do_sample": True,
-                    "repetition_penalty": 1.1
-                }
-            }
-            
             response = requests.post(
-                MODEL_API_URL,
+                HF_API_URL,
                 headers=headers,
                 json=payload,
                 timeout=MODEL_TIMEOUT
             )
-            
-            # Handle model loading case
-            if response.status_code == 503:
-                eta = response.json().get('estimated_time', 30)
-                logger.warning(f"Model is loading, estimated time: {eta} seconds")
-                return None
-                
             response.raise_for_status()
-            
-            # Clean up the response
-            generated_text = response.json()[0]['generated_text']
-            clean_response = generated_text.replace(prompt, "").strip()
-            
-            # Ensure response ends with proper punctuation
-            if clean_response and clean_response[-1] not in {'.', '!', '?'}:
-                clean_response += '.'
-                
-            return clean_response
-            
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Model API request failed: {str(e)}")
-            return None
-        except (KeyError, IndexError, TypeError) as e:
-            logger.error(f"Failed to parse model response: {str(e)}")
+            return response.json()[0]['generated_text']
+        except Exception as e:
+            logger.error(f"Model error: {str(e)}")
             return None
 
-@app.route('/api/chat', methods=['POST'])
-def handle_chat():
-    """Main chat endpoint"""
+@app.route('/chat', methods=['POST'])
+def chat():
     try:
         data = request.get_json()
-        if not data or 'message' not in data:
-            raise ValueError("Invalid request format")
-            
-        message = data['message'].strip()
-        if not message:
-            raise ValueError("Empty message received")
-        
-        conversation_id = data.get('conversation_id', '')
-        logger.info(f"Processing message: '{message}' (conversation: {conversation_id})")
+        message = data.get('message', '').strip()
         
         chatbot = RupeiaChatbot()
+        model_response = chatbot.query_model(message)
         
-        # Try to get model response first
-        model_response = chatbot.generate_model_response(message)
-        
-        # Determine response source
         if model_response:
-            response_text = model_response
-            quick_replies = []  # Model responses typically don't need quick replies
-            source = "model"
-            logger.debug("Using model-generated response")
-        elif FALLBACK_ENABLED:
-            response_text, quick_replies = chatbot.get_fallback_response(message)
-            source = "fallback"
-            logger.debug("Using fallback response")
-        else:
-            raise RuntimeError("No response available")
-        
-        return jsonify({
-            'text': response_text,
-            'quickReplies': quick_replies,
-            'conversation_id': conversation_id,
-            'source': source
-        })
+            return jsonify({
+                'text': model_response,
+                'source': 'model'
+            })
         
-    except ValueError as e:
-        logger.warning(f"Invalid request: {str(e)}")
-        return jsonify({
-            'text': "Please provide a valid message.",
-            'quickReplies': [],
-            'conversation_id': data.get('conversation_id', ''),
-            'source': 'error'
-        }), 400
+        if FALLBACK_ENABLED:
+            text, replies = chatbot.get_fallback(message)
+            return jsonify({
+                'text': text,
+                'quick_replies': replies,
+                'source': 'fallback'
+            })
+            
     except Exception as e:
-        logger.error(f"Error processing chat request: {str(e)}")
-        return jsonify({
-            'text': "Sorry, I'm having trouble responding. Please try again later.",
-            'quickReplies': [],
-            'conversation_id': data.get('conversation_id', ''),
-            'source': 'error'
-        }), 500
+        logger.error(f"Chat error: {str(e)}")
+    
+    return jsonify({
+        'text': "Service unavailable. Please try later.",
+        'source': 'error'
+    }), 503
 
 @app.route('/')
-def serve_index():
-    """Serve the main index page"""
+def home():
     return send_from_directory('templates', 'index.html')
 
-@app.route('/static/<path:path>')
-def serve_static(path):
-    """Serve static files"""
-    return send_from_directory('static', path)
-
 if __name__ == '__main__':
-    port = int(os.getenv("PORT", 5000))
-    debug_mode = os.getenv("DEBUG", "false").lower() == "true"
-    
-    logger.info(f"Starting Rupeia Chatbot on port {port}")
-    logger.info(f"Model API: {'enabled' if API_KEY else 'disabled'}")
-    logger.info(f"Fallback responses: {'enabled' if FALLBACK_ENABLED else 'disabled'}")
-    
-    app.run(
-        host='0.0.0.0',
-        port=port,
-        debug=debug_mode,
-        use_reloader=False
-    )
+    app.run(debug=False, host='0.0.0.0', port=8080)