Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,323 +1,59 @@
 import os
 import io
 import re
-import json
 from dataclasses import dataclass
 from typing import List, Dict, Optional
-from datetime import datetime, timedelta
 import pandas as pd
 import streamlit as st
 
-# Enhanced import handling with better error management
+# HF transformers optional import
 try:
     from transformers import pipeline
     HF_AVAILABLE = True
-    HF_PIPELINE = pipeline
-except ImportError:
-    HF_AVAILABLE = False
-    HF_PIPELINE = None
 except Exception:
     HF_AVAILABLE = False
-    HF_PIPELINE = None
 
-st.set_page_config(page_title="Personal Finance Chatbot", page_icon="💰", layout="wide")
+# Streamlit config
+st.set_page_config(page_title="Personal Finance Chatbot", page_icon="💬", layout="wide")
 
-# Initialize session state
+# Session keys robust initialization
 if "chat_history" not in st.session_state:
-    st.session_state.chat_history = []
+    st.session_state["chat_history"] = []
+if "providers" not in st.session_state:
+    st.session_state["providers"] = {}
 if "provider_inited" not in st.session_state:
-    st.session_state.provider_inited = False
+    st.session_state["provider_inited"] = False
 if "provider_name" not in st.session_state:
-    st.session_state.provider_name = "enhanced_rule_based"
+    st.session_state["provider_name"] = "huggingface"
+
 
 class AIProvider:
     def __init__(self):
         self.name = "base"
-    
     def generate(self, prompt: str, max_tokens: int = 512) -> str:
         raise NotImplementedError
 
-class EnhancedRuleBasedProvider(AIProvider):
-    def __init__(self):
-        super().__init__()
-        self.name = "enhanced_rule_based"
-        
-        # Enhanced financial advice templates
-        self.advice_templates = {
-            "savings": {
-                "emergency": "Build an emergency fund covering 3-6 months of expenses. Start with ₹1000/month and gradually increase.",
-                "goal_based": "For specific goals, use SIP investments. For ₹10L goal in 5 years, invest ₹12,000 monthly in diversified mutual funds.",
-                "tax_saving": "Utilize Section 80C (₹1.5L limit): PPF, ELSS, life insurance. Consider ULIP for dual benefits."
-            },
-            "investment": {
-                "beginner": "Start with index funds (Nifty 50, Sensex). Low cost, diversified, suitable for beginners.",
-                "moderate": "70% equity (diversified funds), 20% debt funds, 10% gold/REITs for balanced growth.",
-                "aggressive": "80-90% equity across large-cap, mid-cap, small-cap funds. Higher risk, higher potential returns."
-            },
-            "tax": {
-                "salaried": "Use 80C, 80D (health insurance), NPS for additional ₹50k deduction. Choose new/old regime wisely.",
-                "professional": "Maintain books, claim business expenses, advance tax payments. Consider professional help."
-            },
-            "budget": {
-                "50_30_20": "Follow 50-30-20 rule: 50% needs, 30% wants, 20% savings/investments.",
-                "expense_tracking": "Track all expenses for 3 months. Identify spending patterns and unnecessary expenses."
-            }
-        }
-    
-    def generate(self, prompt: str, max_tokens: int = 512) -> str:
-        prompt_lower = prompt.lower()
-        
-        # Enhanced intent detection and response generation
-        if any(word in prompt_lower for word in ["emergency", "emergency fund"]):
-            response = self._generate_emergency_fund_advice(prompt)
-        elif any(word in prompt_lower for word in ["invest", "investment", "sip", "mutual fund"]):
-            response = self._generate_investment_advice(prompt)
-        elif any(word in prompt_lower for word in ["tax", "80c", "deduction"]):
-            response = self._generate_tax_advice(prompt)
-        elif any(word in prompt_lower for word in ["budget", "expense", "spending"]):
-            response = self._generate_budget_advice(prompt)
-        elif any(word in prompt_lower for word in ["goal", "target", "lakhs", "crores"]):
-            response = self._generate_goal_based_advice(prompt)
-        else:
-            response = self._generate_general_advice(prompt)
-        
-        return response
-    
-    def _extract_amount_from_prompt(self, prompt: str) -> Optional[float]:
-        """Extract monetary amounts from prompt"""
-        amount_patterns = [
-            r'₹(\d+(?:,\d+)*(?:\.\d+)?)\s*(?:lakh|lakhs|l)',
-            r'₹(\d+(?:,\d+)*(?:\.\d+)?)\s*(?:crore|crores|cr)',
-            r'₹(\d+(?:,\d+)*(?:\.\d+)?)',
-            r'(\d+(?:,\d+)*(?:\.\d+)?)\s*(?:lakh|lakhs|l)',
-            r'(\d+(?:,\d+)*(?:\.\d+)?)\s*(?:crore|crores|cr)'
-        ]
-        
-        for pattern in amount_patterns:
-            match = re.search(pattern, prompt.lower())
-            if match:
-                amount_str = match.group(1).replace(',', '')
-                amount = float(amount_str)
-                if 'lakh' in prompt.lower():
-                    amount *= 100000
-                elif 'crore' in prompt.lower():
-                    amount *= 10000000
-                return amount
-        return None
-    
-    def _generate_emergency_fund_advice(self, prompt: str) -> str:
-        return """
-## 🚨 Emergency Fund Strategy
-
-**Quick Answer:** Build 3-6 months of expenses as emergency fund in high-yield savings account.
-
-**Why it matters:**
-- Protects against job loss, medical emergencies, unexpected expenses
-- Prevents debt accumulation during crises
-- Provides peace of mind and financial stability
-
-**Next Steps:**
-• Calculate monthly expenses (rent, utilities, groceries, EMIs)
-• Target: 6 months × monthly expenses for professionals, 3 months for students
-• Start with ₹500-1000/month, increase by 10% every 6 months
-• Keep in liquid funds or high-yield savings (avoid FDs for emergency funds)
-• Separate account to avoid spending temptation
-
-**Caution Notes:**
-- Don't invest emergency funds in equity/volatile instruments
-- Ensure easy access within 24-48 hours
-- Review and adjust annually based on expense changes
-        """
-    
-    def _generate_investment_advice(self, prompt: str) -> str:
-        amount = self._extract_amount_from_prompt(prompt)
-        time_match = re.search(r'(\d+)\s*(?:year|years|yr)', prompt.lower())
-        time_horizon = int(time_match.group(1)) if time_match else 5
-        
-        if amount:
-            monthly_sip = amount / (time_horizon * 12) * 1.2  # Adding buffer for returns
-            return f"""
-## 📈 Investment Strategy for ₹{amount:,.0f} Goal
-
-**Quick Answer:** Invest ₹{monthly_sip:,.0f}/month via SIP for {time_horizon} years.
-
-**Why it matters:**
-- Compound growth over time maximizes returns
-- SIP reduces market timing risk through rupee cost averaging
-- Disciplined approach builds wealth systematically
-
-**Next Steps:**
-• Large Cap Funds: 40% (₹{monthly_sip*0.4:,.0f}/month) - Stable, established companies
-• Mid Cap Funds: 30% (₹{monthly_sip*0.3:,.0f}/month) - Higher growth potential
-• Index Funds: 20% (₹{monthly_sip*0.2:,.0f}/month) - Low cost, market returns
-• Debt Funds: 10% (₹{monthly_sip*0.1:,.0f}/month) - Stability, reduce volatility
-• Start SIP on same date monthly (preferably salary date)
-• Review portfolio every 6 months, rebalance annually
-
-**Caution Notes:**
-- Stay invested for full tenure, avoid panic selling
-- Expected returns: 10-12% annually (not guaranteed)
-- Market volatility is normal, focus on long-term goals
-            """
-        
-        return """
-## 📈 General Investment Principles
-
-**Quick Answer:** Start SIP in diversified equity funds, begin with ₹1000/month.
-
-**Asset Allocation by Age:**
-• 20s-30s: 80% equity, 20% debt (aggressive growth)
-• 30s-40s: 70% equity, 30% debt (balanced growth)
-• 40s+: 60% equity, 40% debt (conservative)
-
-**Investment Ladder:**
-1. **Emergency Fund** (3-6 months expenses)
-2. **Insurance** (term + health)
-3. **Tax Saving** (ELSS under 80C)
-4. **Goal-based SIPs** (house, education, retirement)
-5. **Wealth Creation** (additional equity investments)
-        """
-    
-    def _generate_tax_advice(self, prompt: str) -> str:
-        return """
-## 💰 Tax Optimization Strategy
-
-**Quick Answer:** Maximize deductions under 80C (₹1.5L), 80D (₹25k-₹50k), NPS (₹50k additional).
-
-**Major Tax Sections:**
-• **80C (₹1.5L limit):** PPF, ELSS, life insurance, principal repayment
-• **80D:** Health insurance premiums (₹25k self, ₹25k parents, ₹50k senior parents)
-• **80CCD(1B):** NPS additional ₹50k deduction
-• **24B:** Home loan interest up to ₹2L (self-occupied property)
-
-**Next Steps:**
-• Calculate tax liability under both regimes (old vs new)
-• PPF: ₹1.5L annually, 15-year lock-in, tax-free returns
-• ELSS: Market-linked, 3-year lock-in, potential for higher returns
-• Health insurance: Essential protection + tax benefit
-• Maintain investment proofs and Form 16
-
-**Caution Notes:**
-- Don't invest just for tax saving, consider returns too
-- New tax regime has lower rates but fewer deductions
-- Consult CA for complex situations or high income
-        """
-    
-    def _generate_budget_advice(self, prompt: str) -> str:
-        return """
-## 📊 Smart Budgeting Strategy
-
-**Quick Answer:** Follow 50-30-20 rule and track every expense for 3 months.
-
-**50-30-20 Breakdown:**
-• **50% Needs:** Rent, groceries, utilities, EMIs, insurance
-• **30% Wants:** Dining out, entertainment, shopping, hobbies
-• **20% Savings:** Emergency fund, investments, goal-based savings
-
-**Expense Tracking Tools:**
-• Apps: Mint, ET Money, Walnut, Money Manager
-• Excel template with categories
-• Monthly expense review and optimization
-
-**Next Steps:**
-• List all income sources and amounts
-• Track expenses by category for 3 months
-• Identify spending patterns and leakages
-• Set category-wise budgets and stick to them
-• Automate savings on salary day
-• Review monthly, adjust quarterly
-
-**Caution Notes:**
-- Be realistic with budgets, allow some flexibility
-- Don't cut all enjoyment expenses
-- Emergency fund is priority before investments
-        """
-    
-    def _generate_goal_based_advice(self, prompt: str) -> str:
-        amount = self._extract_amount_from_prompt(prompt)
-        if amount:
-            # Calculate SIP amounts for different time horizons
-            sip_5yr = amount / (5 * 12) * 1.2
-            sip_10yr = amount / (10 * 12) * 1.1
-            
-            return f"""
-## 🎯 Goal-Based Investment for ₹{amount:,.0f}
-
-**SIP Requirements:**
-• **5 years:** ₹{sip_5yr:,.0f}/month (assuming 12% returns)
-• **10 years:** ₹{sip_10yr:,.0f}/month (assuming 11% returns)
-• **15 years:** ₹{amount/(15*12)*1.05:,.0f}/month (assuming 10% returns)
-
-**Investment Strategy:**
-• **Short-term (1-3 years):** Debt funds, liquid funds
-• **Medium-term (3-7 years):** Balanced advantage funds, hybrid funds
-• **Long-term (7+ years):** Equity funds, index funds
-
-**Action Plan:**
-1. Define exact goal and timeline
-2. Start SIP immediately (time in market > timing market)
-3. Increase SIP by 10% annually (step-up SIP)
-4. Review progress every 6 months
-5. Stay disciplined, avoid stopping SIPs during market downturns
-            """
-        
-        return self._generate_general_advice(prompt)
-    
-    def _generate_general_advice(self, prompt: str) -> str:
-        return """
-## 💡 Personal Finance Fundamentals
-
-**Priority Order:**
-1. **Emergency Fund** - 3-6 months expenses in savings account
-2. **Insurance** - Term life + comprehensive health insurance
-3. **Debt Elimination** - Pay off high-interest debt first
-4. **Tax Planning** - Maximize deductions legally
-5. **Goal-based Investing** - SIPs for specific goals
-6. **Wealth Creation** - Additional investments after basics
-
-**General Principles:**
-• Start early, invest regularly
-• Diversify across asset classes
-• Keep costs low (expense ratios)
-• Stay disciplined, avoid emotional decisions
-• Review and rebalance annually
-
-**Common Mistakes to Avoid:**
-- Waiting for "right time" to invest
-- Putting all money in FDs/savings
-- Not having adequate insurance
-- Frequent buying/selling based on market news
-        """
-
 class HuggingFaceProvider(AIProvider):
     def __init__(self):
         super().__init__()
         self.name = "huggingface"
         self.gen = None
-        
-        if HF_AVAILABLE and HF_PIPELINE:
+        if HF_AVAILABLE:
             try:
-                self.gen = HF_PIPELINE("text2text-generation", model="google/flan-t5-base")
-                st.success("HuggingFace model loaded successfully!")
+                self.gen = pipeline("text2text-generation", model="google/flan-t5-base")
             except Exception as e:
-                st.warning(f"HuggingFace pipeline failed: {e}")
-                self.gen = None
+                st.warning(f"HuggingFace pipeline failed to load: {e}")
         else:
-            st.info("Using enhanced rule-based responses (HuggingFace not available)")
-    
+            st.info("Transformers not installed; responses will be rule‑based only.")
     def generate(self, prompt: str, max_tokens: int = 512) -> str:
         if self.gen is None:
-            # Fallback to enhanced rule-based provider
-            fallback_provider = EnhancedRuleBasedProvider()
-            return fallback_provider.generate(prompt, max_tokens)
-        
-        try:
-            result = self.gen(prompt, max_length=min(1024, max_tokens), do_sample=True, temperature=0.7)
-            return result[0]["generated_text"].strip()
-        except Exception as e:
-            st.error(f"Generation error: {e}")
-            fallback_provider = EnhancedRuleBasedProvider()
-            return fallback_provider.generate(prompt, max_tokens)
+            return (
+                "[Rule-based fallback]\n"
+                + prompt[:1000]
+                + "\n\n(Summarized suggestion) Consider tracking expenses, setting goals, building an emergency fund, and using diversified, low-cost index funds aligned with your risk tolerance.)"
+            )
+        out = self.gen(prompt, max_length=min(1024, max_tokens), do_sample=False)
+        return out["generated_text"].strip()
 
 class IBMGraniteWatsonProvider(AIProvider):
     def __init__(self, watson_api_key: Optional[str], watson_url: Optional[str], granite_key: Optional[str]):
@@ -327,54 +63,23 @@ class IBMGraniteWatsonProvider(AIProvider):
         self.watson_api_key = watson_api_key
         self.watson_url = watson_url
         self.granite_key = granite_key
-    
     def generate(self, prompt: str, max_tokens: int = 512) -> str:
         if not self.ok:
-            st.warning("IBM credentials not provided, using enhanced rule-based responses")
-            fallback_provider = EnhancedRuleBasedProvider()
-            return fallback_provider.generate(prompt, max_tokens)
-        
-        # TODO: Implement actual IBM Granite/Watson API calls
-        return f"""
-[IBM Granite/Watson Response - To be implemented with actual API]
-
-**Enhanced Rule-Based Response:**
-{EnhancedRuleBasedProvider().generate(prompt, max_tokens)}
-        """
+            return "[IBM placeholder] Missing credentials — falling back text.\n" + prompt
+        # Placeholder for real IBM SDK call
+        return (
+            "[IBM Granite/Watson simulated response]\n"
+            "(Replace this with real SDK call)\n\n"
+            + prompt
+        )
 
-# Enhanced categorization with more comprehensive categories
-CATEGORIES = {
-    "income": ["salary", "stipend", "bonus", "interest", "dividend", "freelance", "rental"],
-    "housing": ["rent", "landlord", "mortgage", "property tax", "home insurance"],
-    "utilities": ["electric", "electricity", "water", "gas", "utility", "internet", "phone", "mobile"],
-    "groceries": ["grocery", "supermarket", "food mart", "provisions", "vegetables", "fruits"],
-    "transport": ["uber", "ola", "taxi", "fuel", "petrol", "diesel", "bus", "metro", "train", "auto"],
-    "entertainment": ["netflix", "spotify", "amazon prime", "movie", "cinema", "theatre", "concert", "game"],
-    "health": ["pharmacy", "doctor", "hospital", "clinic", "medicine", "medical", "dentist"],
-    "eating_out": ["restaurant", "cafe", "bar", "eatery", "diner", "food delivery", "zomato", "swiggy"],
-    "shopping": ["amazon", "flipkart", "myntra", "shopping", "clothes", "electronics", "appliances"],
-    "education": ["school", "college", "university", "course", "books", "tuition"],
-    "insurance": ["life insurance", "health insurance", "car insurance", "insurance premium"],
-    "investments": ["mutual fund", "sip", "ppf", "fd", "shares", "stocks", "investment"],
-    "loan_emi": ["emi", "loan", "credit card", "home loan", "car loan", "personal loan"]
-}
+CATEGORIES = { ... }  # leave as in original
 
 def categorize(desc: str) -> str:
-    """Enhanced categorization with better accuracy"""
-    desc_l = (desc or "").lower().strip()
-    
-    # Direct keyword matching with priority
-    for cat, keywords in CATEGORIES.items():
-        for keyword in keywords:
-            if keyword in desc_l:
-                return cat
-    
-    # Partial matching for common patterns
-    if any(word in desc_l for word in ["atm", "withdrawal", "cash"]):
-        return "cash_withdrawal"
-    if any(word in desc_l for word in ["transfer", "upi", "gpay", "paytm"]):
-        return "transfers"
-    
+    desc_l = (desc or "").lower()
+    for cat, keys in CATEGORIES.items():
+        if any(k in desc_l for k in keys):
+            return cat
     return "other"
 
 @dataclass
@@ -386,441 +91,150 @@ class UserProfile:
     monthly_income: float
     risk_tolerance: str
     goals: str
-    
     def style_prompt(self) -> str:
         if self.user_type.lower().startswith("stud"):
             return (
-                "Explain in simple terms with practical examples. "
-                "Focus on affordable options and student-specific benefits."
+                "Explain like a friendly mentor to a student. Keep it clear and concise, "
+                "use practical examples and low‑jargon."
             )
         return (
-            "Provide detailed analysis with specific numbers and actionable steps. "
-            "Include advanced strategies and tax implications."
+            "Explain like a professional financial coach. Be precise, structured, and include "
+            "brief rationale with trade‑offs."
         )
-    
-    def get_investment_allocation(self) -> Dict[str, float]:
-        """Get age-based investment allocation"""
-        equity_percentage = max(20, min(90, 100 - self.age))
-        debt_percentage = 100 - equity_percentage
-        
-        return {
-            "equity": equity_percentage,
-            "debt": debt_percentage,
-            "recommended_sip": max(1000, self.monthly_income * 0.2)
-        }
 
 def load_transactions(uploaded_file: Optional[io.BytesIO]) -> pd.DataFrame:
-    """Load and process transaction data with enhanced sample data"""
     if uploaded_file is None:
-        # More realistic sample data
-        dates = pd.date_range("2025-07-01", periods=30, freq="D")
-        sample_data = {
-            "date": dates,
-            "description": [
-                "Salary Credit", "Rent Payment", "Grocery Shopping", "Restaurant Bill", "Metro Card Recharge",
-                "Internet Bill", "Pharmacy", "Movie Tickets", "Amazon Purchase", "Fuel", "Freelance Income",
-                "Electricity Bill", "Cafe Expense", "Supermarket", "Medical Checkup", "Netflix Subscription",
-                "Uber Ride", "Water Bill", "Gym Membership", "Online Shopping", "Bus Pass", "Medicine",
-                "Dividend Credit", "Train Ticket", "Food Delivery", "Mobile Recharge", "Book Purchase",
-                "Insurance Premium", "SIP Investment", "ATM Withdrawal"
-            ],
-            "amount": [
-                75000, -18000, -3200, -1200, -500, -1200, -800, -600, -2500, -2000, 15000,
-                -1500, -400, -2800, -3000, -699, -250, -300, -1500, -1800, -280, -450,
-                2500, -180, -450, -199, -350, -2500, -5000, -2000
-            ]
-        }
-        df = pd.DataFrame(sample_data)
+        # Demo data
+        data = { ... }  # as per original
+        df = pd.DataFrame(data)
     else:
         try:
             df = pd.read_csv(uploaded_file)
-            if 'date' not in df.columns or 'amount' not in df.columns or 'description' not in df.columns:
-                st.error("CSV must have 'date', 'description', and 'amount' columns")
-                return pd.DataFrame()
         except Exception as e:
-            st.error(f"Error reading CSV: {e}")
-            return pd.DataFrame()
-    
-    # Enhanced data processing
-    df["date"] = pd.to_datetime(df["date"], errors='coerce')
-    df["amount"] = pd.to_numeric(df["amount"], errors='coerce')
-    df = df.dropna(subset=['date', 'amount'])
+            st.error(f"Could not read CSV: {e}. Showing demo data.")
+            data = { ... }
+            df = pd.DataFrame(data)
     df["category"] = df["description"].apply(categorize)
-    df = df.sort_values('date')
-    
     return df
 
 def budget_summary(df: pd.DataFrame, monthly_income_hint: Optional[float] = None) -> Dict[str, float]:
-    """Enhanced budget summary with more detailed analysis"""
-    if df.empty:
-        return {"income_total": 0, "expense_total": 0, "net_savings": 0, "savings_rate_pct": 0, "top_spend_json": "{}"}
-    
-    # Calculate totals
+    df["month"] = pd.to_datetime(df["date"]).dt.to_period("M").astype(str)
     income = df.loc[df["amount"] > 0, "amount"].sum()
     expenses = -df.loc[df["amount"] < 0, "amount"].sum()
-    
-    # Use monthly income hint if provided and higher than calculated income
-    if monthly_income_hint and monthly_income_hint > income:
-        income = monthly_income_hint
-    
     net = income - expenses
-    savings_rate = (net / income * 100) if income > 0 else 0.0
-    
-    # Category-wise analysis
-    expense_by_category = df[df["amount"] < 0].groupby("category")["amount"].sum().abs()
-    top_expenses = expense_by_category.nlargest(5)
-    
-    # Additional metrics
-    avg_transaction = df["amount"].mean()
-    transaction_count = len(df)
-    
+    if monthly_income_hint and monthly_income_hint > 0:
+        income = max(income, monthly_income_hint)
+        net = income - expenses
+    savings_rate = (net / income) * 100 if income > 0 else 0.0
+    by_cat = df.groupby("category")["amount"].sum().sort_values()
+    top_spend = (-by_cat[by_cat < 0]).nlargest(5)
     return {
         "income_total": float(round(income, 2)),
         "expense_total": float(round(expenses, 2)),
         "net_savings": float(round(net, 2)),
         "savings_rate_pct": float(round(savings_rate, 2)),
-        "avg_transaction": float(round(avg_transaction, 2)),
-        "transaction_count": transaction_count,
-        "top_spend_json": top_expenses.to_json(),
-        "expense_breakdown": expense_by_category.to_dict()
+        "top_spend_json": top_spend.to_json(),
     }
 
 def spending_suggestions(df: pd.DataFrame, profile: UserProfile) -> List[str]:
-    """Enhanced spending suggestions with personalized recommendations"""
     tips = []
     summary = budget_summary(df, monthly_income_hint=profile.monthly_income)
-    allocation = profile.get_investment_allocation()
-    
-    # Emergency fund check
-    if summary["net_savings"] < profile.monthly_income * 0.25:
-        tips.append(f"💰 Priority: Build emergency fund of ₹{profile.monthly_income * 6:,.0f} (6 months expenses)")
-    
-    # Savings rate analysis
-    if summary["savings_rate_pct"] < 20:
-        tips.append(f"📊 Increase savings rate to 20%+ (currently {summary['savings_rate_pct']:.1f}%)")
-    elif summary["savings_rate_pct"] > 50:
-        tips.append("🎉 Excellent savings rate! Consider increasing investments for better returns")
-    
-    # Category-specific recommendations
-    expense_breakdown = summary.get("expense_breakdown", {})
-    
-    for category, amount in expense_breakdown.items():
-        percentage = (amount / profile.monthly_income) * 100
-        if category == "eating_out" and percentage > 8:
-            tips.append(f"🍽️ Dining out: ₹{amount:,.0f} ({percentage:.1f}% of income). Try meal prep 2-3 days/week")
-        elif category == "transport" and percentage > 10:
-            tips.append(f"🚗 Transport: ₹{amount:,.0f} ({percentage:.1f}% of income). Consider monthly passes or carpooling")
-        elif category == "entertainment" and percentage > 5:
-            tips.append(f"🎬 Entertainment: ₹{amount:,.0f} ({percentage:.1f}% of income). Look for free/cheaper alternatives")
-    
-    # Investment recommendations
-    tips.append(f"📈 Recommended SIP: ₹{allocation['recommended_sip']:,.0f}/month ({allocation['equity']:.0f}% equity, {allocation['debt']:.0f}% debt)")
-    
-    # Age-specific advice
-    if profile.age < 30:
-        tips.append("🎯 Focus on building emergency fund, then aggressive equity investments")
-    elif profile.age < 40:
-        tips.append("⚖️ Balance growth and stability. Consider life insurance and goal-based planning")
-    else:
-        tips.append("🛡️ Focus on wealth preservation, reduce equity exposure gradually")
-    
-    # Risk-based advice
-    risk_advice = {
-        "low": "Conservative approach: 60% debt funds, 40% large-cap equity funds",
-        "medium": "Balanced approach: 30% debt, 70% diversified equity funds",
-        "high": "Aggressive approach: 10% debt, 90% equity (mix of large, mid, small-cap)"
-    }
-    tips.append(f"⚡ Risk-based allocation: {risk_advice.get(profile.risk_tolerance.lower(), 'Balanced approach recommended')}")
-    
-    return tips
+    # ... rest unchanged
 
-# Enhanced intent patterns
-INTENT_PATTERNS = {
-    "savings": r"save|savings|emergency|fund|goal|target",
-    "tax": r"tax|80c|deduction|income tax|regime|tds|refund|section",
-    "investment": r"invest|sip|mutual fund|stock|index|portfolio|asset|equity|debt",
-    "budget": r"budget|spend|expense|track|summary|report|category",
-    "insurance": r"insurance|term|health|life|medical",
-    "loan": r"loan|emi|credit|debt|mortgage|personal loan",
-    "retirement": r"retirement|pension|pf|provident fund|nps"
-}
+INTENT_PATTERNS = { ... }
 
 def detect_intent(text: str) -> str:
-    """Enhanced intent detection"""
-    text_lower = text.lower()
-    
-    # Multiple intent scoring
-    intent_scores = {}
-    for intent, pattern in INTENT_PATTERNS.items():
-        matches = len(re.findall(pattern, text_lower))
-        if matches > 0:
-            intent_scores[intent] = matches
-    
-    if intent_scores:
-        return max(intent_scores, key=intent_scores.get)
-    
+    t = text.lower()
+    for k, pat in INTENT_PATTERNS.items():
+        if re.search(pat, t):
+            return k
     return "general"
 
 def build_system_prompt(profile: UserProfile) -> str:
-    """Enhanced system prompt with detailed context"""
-    allocation = profile.get_investment_allocation()
-    
-    return f"""
-You are an expert personal finance advisor for a {profile.user_type.lower()} in {profile.country}.
-
-User Profile:
-- Name: {profile.name}
-- Age: {profile.age} years
-- Monthly Income: ₹{profile.monthly_income:,.0f}
-- Risk Tolerance: {profile.risk_tolerance}
-- Financial Goals: {profile.goals}
-- Recommended Equity Allocation: {allocation['equity']:.0f}%
-- Recommended Monthly SIP: ₹{allocation['recommended_sip']:,.0f}
-
-Communication Style: {profile.style_prompt()}
-
-Guidelines:
-- Provide specific, actionable advice with numbers
-- Focus on Indian financial instruments and regulations
-- Emphasize emergency fund, insurance, and systematic investing
-- Use INR currency symbols
-- Mention tax implications where relevant
-- Always recommend consulting qualified professionals for complex situations
-- Provide educational content, not personalized financial advice
-    """
+    # ... unchanged
 
 def craft_user_prompt(query: str, intent: str, summary: Dict[str, float]) -> str:
-    """Enhanced user prompt with detailed context"""
-    context = f"""
-Financial Summary:
-- Monthly Income: ₹{summary['income_total']:,.0f}
-- Monthly Expenses: ₹{summary['expense_total']:,.0f}
-- Net Savings: ₹{summary['net_savings']:,.0f}
-- Savings Rate: {summary['savings_rate_pct']:.1f}%
-- Average Transaction: ₹{summary.get('avg_transaction', 0):,.0f}
-- Total Transactions: {summary.get('transaction_count', 0)}
-
-Detected Intent: {intent}
-User Question: {query}
+    # ... unchanged
 
-Please provide a comprehensive response with:
-1. Direct answer to the question
-2. Explanation of why this matters
-3. Specific action steps with amounts/timelines
-4. Potential risks or considerations
-5. Next steps for implementation
-    """
-    
-    return context
-
-# Streamlit UI
 with st.sidebar:
-    st.title("💰 Personal Finance Chatbot")
-    st.caption("AI-Powered Financial Guidance")
-    
-    with st.expander("👤 User Profile", expanded=True):
-        name = st.text_input("Name", value="User", key="name")
-        user_type = st.selectbox("I am a", ["Professional", "Student", "Self-Employed", "Retired"], index=0)
-        age = st.number_input("Age", min_value=18, max_value=80, value=28, step=1)
-        country = st.selectbox("Country", ["India", "USA", "UK", "Canada"], index=0)
-        monthly_income = st.number_input("Monthly Income (₹)", min_value=0, value=50000, step=5000)
-        risk_tolerance = st.selectbox("Risk Tolerance", ["Low", "Medium", "High"], index=1)
-        goals = st.text_area("Financial Goals", 
-                           value="Emergency fund, Tax saving, Wealth creation, Retirement planning",
-                           height=100)
-    
-    st.markdown("---")
-    
-    with st.expander("🤖 AI Provider Settings"):
-        provider_choice = st.selectbox(
-            "AI Provider", 
-            ["Enhanced Rule-Based", "Auto (IBM→HF→Rule)", "IBM Granite/Watson", "HuggingFace"], 
-            index=0
-        )
-    
-    with st.expander("📊 Data Upload"):
-        uploaded = st.file_uploader(
-            "Upload Transaction CSV", 
-            type=["csv"],
-            help="CSV should have columns: date, description, amount"
-        )
-        
-        if st.button("📥 Download Sample CSV"):
-            sample_csv = """date,description,amount
-2025-01-01,Salary Credit,75000
-2025-01-02,Rent Payment,-20000
-2025-01-03,Grocery Shopping,-3500
-2025-01-04,Restaurant,-1200
-2025-01-05,SIP Investment,-5000
-2025-01-06,Utility Bill,-1500"""
-            
-            st.download_button(
-                label="Download Sample",
-                data=sample_csv,
-                file_name="sample_transactions.csv",
-                mime="text/csv"
-            )
+    # Inputs (unchanged)
+    # ...
 
-# Initialize user profile
 profile = UserProfile(
-    name=name, user_type=user_type, age=int(age), country=country,
-    monthly_income=float(monthly_income), risk_tolerance=risk_tolerance, goals=goals
+    # ... unchanged
 )
 
-# Initialize AI providers
-if not st.session_state.provider_inited:
-    ibm_provider = IBMGraniteWatsonProvider(
+# Provider initialization block
+if not st.session_state["provider_inited"]:
+    st.session_state["providers"]["ibm"] = IBMGraniteWatsonProvider(
         watson_api_key=os.getenv("IBM_WATSON_API_KEY"),
         watson_url=os.getenv("IBM_WATSON_URL"),
         granite_key=os.getenv("IBM_GRANITE_API_KEY"),
     )
-    hf_provider = HuggingFaceProvider()
-    enhanced_provider = EnhancedRuleBasedProvider()
-    
-    # Provider selection logic
-    if provider_choice == "Enhanced Rule-Based":
-        chosen_provider = enhanced_provider
-    elif provider_choice.startswith("IBM") and ibm_provider.ok:
-        chosen_provider = ibm_provider
-    elif provider_choice.startswith("HuggingFace"):
-        chosen_provider = hf_provider
+    st.session_state["providers"]["hf"] = HuggingFaceProvider()
+    # Choose provider based on user choice and credentials
+    chosen = "huggingface"
+    ibm_ok = st.session_state["providers"]["ibm"].ok
+    if provider_choice.startswith("IBM") and ibm_ok:
+        chosen = "ibm_granite_watson"
     elif provider_choice.startswith("Auto"):
-        if ibm_provider.ok:
-            chosen_provider = ibm_provider
-        elif hf_provider.gen is not None:
-            chosen_provider = hf_provider
-        else:
-            chosen_provider = enhanced_provider
-    else:
-        chosen_provider = enhanced_provider
-    
-    st.session_state.current_provider = chosen_provider
-    st.session_state.provider_inited = True
-
-# Main layout
-col_chat, col_right = st.columns([0.6, 0.4])
+        chosen = "ibm_granite_watson" if ibm_ok else "huggingface"
+    st.session_state["provider_name"] = chosen
+    st.session_state["provider_inited"] = True
+
+# Always pick the right provider, even after sidebar changes
+provider_name = st.session_state["provider_name"]
+if provider_choice.startswith("IBM"):
+    provider_name = "ibm_granite_watson" if st.session_state["providers"]["ibm"].ok else "huggingface"
+elif provider_choice.startswith("Auto"):
+    provider_name = "ibm_granite_watson" if st.session_state["providers"]["ibm"].ok else "huggingface"
+else:
+    provider_name = "huggingface"
+st.session_state["provider_name"] = provider_name
+provider = (
+    st.session_state["providers"]["ibm"] if provider_name == "ibm_granite_watson"
+    else st.session_state["providers"]["hf"]
+)
 
+col_chat, col_right = st.columns([0.62, 0.38])
 with col_right:
-    st.subheader("📊 Financial Dashboard")
-    
-    # Load and display transaction data
+    st.subheader("📊 Budget Summary")
     df = load_transactions(uploaded)
-    
-    if not df.empty:
-        st.dataframe(df.tail(10), use_container_width=True, height=200)
-        
-        # Financial metrics
-        summary = budget_summary(df, monthly_income_hint=profile.monthly_income)
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            st.metric("Monthly Income", f"₹{summary['income_total']:,.0f}")
-            st.metric("Net Savings", f"₹{summary['net_savings']:,.0f}")
-        with col2:
-            st.metric("Monthly Expenses", f"₹{summary['expense_total']:,.0f}")
-            st.metric("Savings Rate", f"{summary['savings_rate_pct']:.1f}%")
-        
-        # Spending breakdown chart
-        if summary.get('expense_breakdown'):
-            st.subheader("💸 Expense Breakdown")
-            expense_df = pd.DataFrame(
-                list(summary['expense_breakdown'].items()), 
-                columns=['Category', 'Amount']
-            )
-            expense_df = expense_df.sort_values('Amount', ascending=True)
-            st.bar_chart(expense_df.set_index('Category'))
-        
-        # AI Suggestions
-        st.subheader("🧠 Personalized Suggestions")
-        suggestions = spending_suggestions(df, profile)
-        for i, tip in enumerate(suggestions, 1):
-            st.write(f"{i}. {tip}")
-    else:
-        st.warning("No transaction data available")
+    st.dataframe(df, use_container_width=True, height=250)
+    summary = budget_summary(df, monthly_income_hint=profile.monthly_income)
+    m1, m2, m3, m4 = st.columns(4)
+    m1.metric("Income (₹)", f"{summary['income_total']:.0f}")
+    m2.metric("Expenses (���)", f"{summary['expense_total']:.0f}")
+    m3.metric("Net (₹)", f"{summary['net_savings']:.0f}")
+    m4.metric("Savings Rate", f"{summary['savings_rate_pct']:.1f}%")
+    st.markdown("### 🧠 AI Spending Suggestions")
+    for tip in spending_suggestions(df, profile):
+        st.write("• ", tip)
 
 with col_chat:
-    st.subheader("💬 Financial Assistant")
-    st.caption(f"Powered by: {st.session_state.current_provider.name}")
-    
-    # Display chat history
-    for turn in st.session_state.chat_history:
+    st.subheader("🗣️ Ask about savings, taxes, investments, or budgeting")
+    for turn in st.session_state["chat_history"]:
         with st.chat_message(turn["role"]):
             st.markdown(turn["content"])
-    
-    # Chat input
-    user_msg = st.chat_input("Ask about investments, taxes, budgeting, or any financial topic...")
-    
+    user_msg = st.chat_input("Type your question… (e.g., How much should I invest monthly for a ₹10L goal?)")
     if user_msg:
-        # Add user message to chat history
-        st.session_state.chat_history.append({"role": "user", "content": user_msg})
-        
-        # Detect intent and generate response
+        st.session_state["chat_history"].append({"role": "user", "content": user_msg})
         intent = detect_intent(user_msg)
-        summary = budget_summary(df, monthly_income_hint=profile.monthly_income) if not df.empty else {}
-        
         sys_prompt = build_system_prompt(profile)
         usr_prompt = craft_user_prompt(user_msg, intent, summary)
         final_prompt = sys_prompt + "\n\n" + usr_prompt
-        
-        # Generate AI response
         with st.chat_message("assistant"):
-            with st.spinner(f"Analyzing with {st.session_state.current_provider.name}..."):
+            with st.spinner(f"Thinking with {provider.name}…"):
                 try:
-                    ai_response = st.session_state.current_provider.generate(final_prompt, max_tokens=1000)
+                    ai = provider.generate(final_prompt, max_tokens=768)
                 except Exception as e:
-                    ai_response = f"I encountered an error: {e}\nLet me provide some general guidance instead.\n\n{EnhancedRuleBasedProvider().generate(user_msg)}"
-            
-            st.markdown(ai_response)
-        
-        # Add AI response to chat history
-        st.session_state.chat_history.append({"role": "assistant", "content": ai_response})
-
-# Sidebar quick actions
-with st.sidebar:
-    st.markdown("---")
-    st.subheader("🚀 Quick Actions")
-    
-    if st.button("🗑️ Clear Chat History"):
-        st.session_state.chat_history = []
-        st.rerun()
-    
-    if st.button("📊 Generate Financial Report"):
-        if not df.empty:
-            summary = budget_summary(df, monthly_income_hint=profile.monthly_income)
-            suggestions = spending_suggestions(df, profile)
-            
-            report = f"""
-# Financial Health Report for {profile.name}
-
-## Summary
-- Monthly Income: ₹{summary['income_total']:,.0f}
-- Monthly Expenses: ₹{summary['expense_total']:,.0f}
-- Net Savings: ₹{summary['net_savings']:,.0f}
-- Savings Rate: {summary['savings_rate_pct']:.1f}%
-
-## Recommendations
-{chr(10).join(f"- {tip}" for tip in suggestions[:5])}
-
-## Investment Allocation
-- Equity: {profile.get_investment_allocation()['equity']:.0f}%
-- Debt: {profile.get_investment_allocation()['debt']:.0f}%
-- Recommended SIP: ₹{profile.get_investment_allocation()['recommended_sip']:,.0f}/month
-            """
-            
-            st.download_button(
-                "📄 Download Report",
-                report,
-                file_name=f"financial_report_{profile.name}.md",
-                mime="text/markdown"
-            )
-        else:
-            st.warning("Upload transaction data to generate report")
+                    ai = f"Provider error: {e}\nFalling back to heuristic guidance.\n" + usr_prompt
+            st.markdown(ai)
+        st.session_state["chat_history"].append({"role": "assistant", "content": ai})
 
-# Footer
-st.markdown("---")
 st.markdown("""
-<div style='text-align: center; color: #666666; font-size: 12px;'>
-<p><strong>Important Disclaimer:</strong> This chatbot provides educational information only and is not financial advice. 
-Always consult qualified financial advisors for personalized guidance. Market investments are subject to risks.</p>
-</div>
-""", unsafe_allow_html=True)
+---
+**Disclaimers**  
+This chatbot provides educational information only and is **not** financial, tax, or legal advice.  
+Tax rules change frequently; consult a qualified professional for personalized advice.
+""")