Update streamlit_app.py

streamlit_app.py

@@ -1,3 +1,4 @@
+
 # budget_tracker_with_voice_ocr.py
 import streamlit as st
 import pandas as pd
@@ -21,17 +22,9 @@ from transformers import pipeline
 import torch
 import pytesseract
 import os
-from langchain_groq import ChatGroq
-from langchain.prompts import PromptTemplate
-from langchain_core.messages import HumanMessage, SystemMessage
-import time
-warnings.filterwarnings('ignore')
-import os
 
-# Force Streamlit to use local writable directory for config
-os.environ["STREAMLIT_HOME"] = os.getcwd()
-os.environ["XDG_CONFIG_HOME"] = os.getcwd()
 
+warnings.filterwarnings('ignore')
 
 # Set Tesseract path (update this path according to your system)
 # For Windows: r"C:\Program Files\Tesseract-OCR\tesseract.exe"
@@ -39,45 +32,13 @@ os.environ["XDG_CONFIG_HOME"] = os.getcwd()
 # For Linux: "/usr/bin/tesseract"
 try:
     # You can set your Tesseract path here
-    TESSERACT_PATH = os.getenv("TESSERACT_PATH", r'"/usr/bin/tesseract"')  # Default for Linux
+    TESSERACT_PATH = os.getenv("TESSERACT_PATH", r'/usr/bin/tesseract')  # Default for Linux
     pytesseract.pytesseract.tesseract_cmd = TESSERACT_PATH
 except:
     pass  # Use default path
-import os
-import warnings
-import logging
-
-# Optional: Hide LangSmith warnings
-warnings.filterwarnings("ignore", category=UserWarning)
-
-# --- Logging Setup ---
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-from dotenv import load_dotenv
-load_dotenv()  # This loads the .env file into environment variables
-
-# --- API Keys ---
-
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-
 
-os.environ["GROQ_API_KEY"] = GROQ_API_KEY
 
 
-# Initialize Groq LLM
-@st.cache_resource
-def get_llm():
-    try:
-        llm = ChatGroq(
-            model="llama3-70b-8192",  # Using a more stable model
-            temperature=0.3,
-            max_tokens=1000,
-        )
-        return llm
-    except Exception as e:
-        st.error(f"Error initializing LLM: {str(e)}")
-        return None
-
 # Initialize session state for data persistence
 def initialize_session_state():
     """Initialize all session state variables"""
@@ -92,8 +53,6 @@ def initialize_session_state():
             st.session_state.notifications = []
         if 'whisper_model' not in st.session_state:
             st.session_state.whisper_model = None
-        if 'financial_insights' not in st.session_state:
-            st.session_state.financial_insights = []
         return True
     except Exception as e:
         st.error(f"Error initializing session state: {str(e)}")
@@ -121,6 +80,7 @@ def transcribe_audio_with_whisper(audio_file_path):
         model = load_whisper_model()
         if model is None:
             return None
+            
         with st.spinner("Transcribing audio..."):
             output = model(
                 audio_file_path,
@@ -153,9 +113,11 @@ def voice_expense_recording():
     """
     try:
         st.subheader("🎤 Voice Expense Recording")
+        
         # Audio input options
         audio_option = st.radio("Choose audio input method:", 
                                ["Microphone (Real-time)", "Upload Audio File"])
+        
         if audio_option == "Microphone (Real-time)":
             # Check if microphone is available
             try:
@@ -164,6 +126,7 @@ def voice_expense_recording():
             except:
                 mic_available = False
                 st.warning("Microphone not available. Please check your device settings.")
+            
             if mic_available and st.button("🎙️ Start Voice Recording"):
                 try:
                     with sr.Microphone() as source:
@@ -171,22 +134,27 @@ def voice_expense_recording():
                         # Adjust for ambient noise
                         recognizer.adjust_for_ambient_noise(source, duration=1)
                         audio = recognizer.listen(source, timeout=10)
+                        
                         # Save audio to temporary file for processing
                         with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp_file:
                             with open(tmp_file.name, "wb") as f:
                                 f.write(audio.get_wav_data())
                             temp_filename = tmp_file.name
+                        
                         # Try Whisper first, fallback to Google
                         text = transcribe_audio_with_whisper(temp_filename)
                         if text is None:
                             text = transcribe_audio_with_google(temp_filename)
+                        
                         # Clean up temporary file
                         os.unlink(temp_filename)
+                        
                         if text:
                             st.success(f"✅ Recognized: {text}")
                             process_voice_text(text)
                         else:
                             st.error("❌ Failed to transcribe audio")
+                            
                 except sr.WaitTimeoutError:
                     st.error("⏰ Timeout: No speech detected within 10 seconds")
                 except sr.UnknownValueError:
@@ -195,8 +163,10 @@ def voice_expense_recording():
                     st.error(f"🌐 Could not request results: {e}")
                 except Exception as e:
                     st.error(f"❌ Error processing voice input: {str(e)}")
+        
         else:  # Upload Audio File
             uploaded_audio = st.file_uploader("Upload Audio File", type=['wav', 'mp3', 'm4a'])
+            
             if uploaded_audio is not None:
                 if st.button("🔊 Process Audio File"):
                     try:
@@ -204,23 +174,29 @@ def voice_expense_recording():
                         with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_audio.name)[1]) as tmp_file:
                             tmp_file.write(uploaded_audio.getvalue())
                             temp_filename = tmp_file.name
+                        
                         # Process audio file
                         with st.spinner("Processing audio file..."):
                             # Try Whisper first, fallback to Google
                             text = transcribe_audio_with_whisper(temp_filename)
                             if text is None:
                                 text = transcribe_audio_with_google(temp_filename)
+                            
                             # Clean up temporary file
                             os.unlink(temp_filename)
+                            
                             if text:
                                 st.success(f"✅ Transcribed: {text}")
                                 process_voice_text(text)
                             else:
                                 st.error("❌ Failed to transcribe audio file")
+                                
                     except Exception as e:
                         st.error(f"❌ Error processing audio file: {str(e)}")
+        
         # Instructions
         st.info("💡 Tip: Say something like 'I spent 500 rupees on groceries at Big Bazaar'")
+        
     except Exception as e:
         st.error(f"❌ Critical error in voice recording: {str(e)}")
 
@@ -233,44 +209,27 @@ def process_voice_text(text):
         category = "Other"
         description = text
         
-        # Use LLM for intelligent categorization
-        llm = get_llm()
-        if llm:
-            try:
-                prompt = f"""
-                Based on this expense description: "{text}"
-                Please categorize it into one of these categories:
-                Food, Transport, Shopping, Entertainment, Bills, Health, Education, Other
-                
-                Respond with only the category name.
-                """
-                response = llm.invoke([SystemMessage(content="You are a financial assistant that categorizes expenses."), 
-                                     HumanMessage(content=prompt)])
-                llm_category = response.content.strip()
-                if llm_category in ["Food", "Transport", "Shopping", "Entertainment", "Bills", "Health", "Education", "Other"]:
-                    category = llm_category
-            except Exception as e:
-                st.warning(f"LLM categorization failed, using rule-based: {str(e)}")
+        # Enhanced category detection
+        categories = {
+            'Food': ['food', 'groceries', 'restaurant', 'cafe', 'meal', 'lunch', 'dinner', 'breakfast', 'dhaba', 'hotel'],
+            'Transport': ['transport', 'travel', 'taxi', 'uber', 'ola', 'bus', 'train', 'flight', 'fuel', 'petrol', 'diesel', 'auto'],
+            'Shopping': ['shopping', 'clothes', 'electronics', 'purchase', 'buy', 'mall', 'store', 'market'],
+            'Entertainment': ['entertainment', 'movie', 'cinema', 'game', 'fun', 'party', 'netflix', 'spotify'],
+            'Bills': ['bill', 'electricity', 'water', 'internet', 'phone', 'rent', 'insurance', 'subscription'],
+            'Health': ['medicine', 'doctor', 'hospital', 'pharmacy', 'health', 'medical'],
+            'Education': ['education', 'school', 'college', 'books', 'course', 'tuition', 'study']
+        }
         
-        # Fallback to rule-based categorization if LLM fails
-        if category == "Other":
-            categories = {
-                'Food': ['food', 'groceries', 'restaurant', 'cafe', 'meal', 'lunch', 'dinner', 'breakfast', 'dhaba', 'hotel'],
-                'Transport': ['transport', 'travel', 'taxi', 'uber', 'ola', 'bus', 'train', 'flight', 'fuel', 'petrol', 'diesel', 'auto'],
-                'Shopping': ['shopping', 'clothes', 'electronics', 'purchase', 'buy', 'mall', 'store', 'market'],
-                'Entertainment': ['entertainment', 'movie', 'cinema', 'game', 'fun', 'party', 'netflix', 'spotify'],
-                'Bills': ['bill', 'electricity', 'water', 'internet', 'phone', 'rent', 'insurance', 'subscription'],
-                'Health': ['medicine', 'doctor', 'hospital', 'pharmacy', 'health', 'medical'],
-                'Education': ['education', 'school', 'college', 'books', 'course', 'tuition', 'study']
-            }
-            text_lower = text.lower()
-            for cat, keywords in categories.items():
-                if any(keyword in text_lower for keyword in keywords):
-                    category = cat
-                    break
+        text_lower = text.lower()
+        for cat, keywords in categories.items():
+            if any(keyword in text_lower for keyword in keywords):
+                category = cat
+                break
         
         # Extract numbers for amount using regex
         amount_pattern = r'(?:$|\$|rs|rupees?|dollars?)\s*(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s*(?:$|\$|rs|rupees?|dollars?)'
+
+        # amount_pattern = r'(?:$|rs|rupees?)\s*(\d+(?:\.\d+)?)|(\d+(?:\.\d+)?)\s*(?:$|rs|rupees?)'
         matches = re.findall(amount_pattern, text_lower)
         if matches:
             for match in matches:
@@ -297,13 +256,11 @@ def process_voice_text(text):
         })
         st.session_state.expenses = pd.concat([st.session_state.expenses, new_expense], ignore_index=True)
         st.success(f"✅ Expense logged: ${amount:.2f} for {category}")
+
         
         # Check budget alerts
         check_budget_alerts(amount, category)
         
-        # Generate financial insight for this expense
-        generate_financial_insight_for_expense(new_expense.iloc[0])
-        
     except Exception as e:
         st.error(f"❌ Error processing voice text: {str(e)}")
 
@@ -333,6 +290,7 @@ class OCRExtractor:
             # Extract text with multiple languages support
             custom_config = r'--oem 3 --psm 6 -l eng'
             text = pytesseract.image_to_string(image, config=custom_config)
+            
             return text.strip()
         except Exception as e:
             st.error(f"OCR Error: {e}")
@@ -380,108 +338,73 @@ def ocr_receipt_processing():
     """
     try:
         st.subheader("📸 Receipt OCR Processing")
+        
         uploaded_file = st.file_uploader("Upload Receipt Image", type=['jpg', 'jpeg', 'png'])
+        
         if uploaded_file is not None:
             try:
                 image = Image.open(uploaded_file)
                 st.image(image, caption="📸 Uploaded Receipt", use_container_width=True)
+                
                 if st.button("🔍 Process Receipt"):
                     # Initialize OCR extractor
                     ocr_extractor = OCRExtractor()
+                    
                     # Use Tesseract OCR
                     try:
                         # Preprocess image for better results
                         processed_image = ocr_extractor.preprocess_image(image)
+                        
                         # Extract text
                         extracted_text = ocr_extractor.extract_text_from_image(processed_image)
+                        
                         if extracted_text:
                             st.text_area("📄 Extracted Text", extracted_text, height=200)
                             
-                            # Use LLM to parse receipt data intelligently
-                            llm = get_llm()
+                            # Parse receipt data
                             amount = 0
                             category = "Other"
                             description = "Receipt expense"
                             
-                            if llm:
-                                try:
-                                    # Extract amount using LLM
-                                    amount_prompt = f"""
-                                    From this receipt text, extract the total amount paid:
-                                    {extracted_text}
-                                    
-                                    Respond with only the numeric amount (e.g., 549.50).
-                                    If you cannot find it, respond with "0".
-                                    """
-                                    amount_response = llm.invoke([
-                                        SystemMessage(content="You are a receipt parsing assistant that extracts payment amounts."),
-                                        HumanMessage(content=amount_prompt)
-                                    ])
-                                    try:
-                                        amount = float(amount_response.content.strip())
-                                    except:
-                                        amount = 0
-                                    
-                                    # Extract category using LLM
-                                    category_prompt = f"""
-                                    Based on this receipt content, categorize the expense into one of these categories:
-                                    Food, Transport, Shopping, Entertainment, Bills, Health, Education, Other
-                                    
-                                    Receipt content: {extracted_text}
-                                    
-                                    Respond with only the category name.
-                                    """
-                                    category_response = llm.invoke([
-                                        SystemMessage(content="You are a financial assistant that categorizes expenses from receipts."),
-                                        HumanMessage(content=category_prompt)
-                                    ])
-                                    llm_category = category_response.content.strip()
-                                    if llm_category in ["Food", "Transport", "Shopping", "Entertainment", "Bills", "Health", "Education", "Other"]:
-                                        category = llm_category
-                                        
-                                except Exception as e:
-                                    st.warning(f"LLM receipt parsing failed: {str(e)}")
+                            # Extract amount with multiple patterns
+                            amount_patterns = [
+                                r'[$$€£]\s*(\d+(?:\.\d+)?)',
+                                r'(\d+(?:\.\d+)?)\s*[$$€£]',
+                                r'(?:total|amount|paid|grand total).*?(\d+(?:\.\d+)?)',
+                                r'(?:bill|invoice).*?(\d+(?:\.\d+)?)'
+                            ]
                             
-                            # Fallback parsing if LLM fails
-                            if amount == 0:
-                                # Extract amount with multiple patterns
-                                amount_patterns = [
-                                    r'[$$€£]\s*(\d+(?:\.\d+)?)',
-                                    r'(\d+(?:\.\d+)?)\s*[$$€£]',
-                                    r'(?:total|amount|paid|grand total).*?(\d+(?:\.\d+)?)',
-                                    r'(?:bill|invoice).*?(\d+(?:\.\d+)?)'
-                                ]
-                                for pattern in amount_patterns:
-                                    matches = re.findall(pattern, extracted_text.lower(), re.IGNORECASE)
-                                    if matches:
-                                        for match in matches:
-                                            if isinstance(match, tuple):
-                                                for group in match:
-                                                    if group and (group.replace('.', '').isdigit()):
-                                                        amount = float(group)
-                                                        break
-                                            elif match.replace('.', '').isdigit():
-                                                amount = float(match)
-                                                break
-                                        if amount > 0:
+                            for pattern in amount_patterns:
+                                matches = re.findall(pattern, extracted_text.lower(), re.IGNORECASE)
+                                if matches:
+                                    for match in matches:
+                                        if isinstance(match, tuple):
+                                            for group in match:
+                                                if group and (group.replace('.', '').isdigit()):
+                                                    amount = float(group)
+                                                    break
+                                        elif match.replace('.', '').isdigit():
+                                            amount = float(match)
                                             break
+                                    if amount > 0:
+                                        break
                             
                             # Enhanced category detection
-                            if category == "Other":
-                                categories_keywords = {
-                                    'Food': ['restaurant', 'cafe', 'grocery', 'food', 'meal', 'supermarket', 'big bazaar', 'dmart', 'walmart'],
-                                    'Transport': ['taxi', 'uber', 'ola', 'fuel', 'petrol', 'bus', 'train', 'airport', 'parking'],
-                                    'Shopping': ['mall', 'store', 'shop', 'purchase', 'clothes', 'electronics', 'amazon', 'flipkart'],
-                                    'Entertainment': ['movie', 'cinema', 'game', 'entertainment', 'theatre', 'netflix'],
-                                    'Bills': ['electricity', 'water', 'internet', 'phone', 'rent', 'subscription', 'bill'],
-                                    'Health': ['pharmacy', 'medicine', 'doctor', 'hospital', 'medical', 'apollo', 'apollo'],
-                                    'Education': ['school', 'college', 'books', 'stationery', 'tution', 'course']
-                                }
-                                text_lower = extracted_text.lower()
-                                for cat, keywords in categories_keywords.items():
-                                    if any(keyword in text_lower for keyword in keywords):
-                                        category = cat
-                                        break
+                            categories_keywords = {
+                                'Food': ['restaurant', 'cafe', 'grocery', 'food', 'meal', 'supermarket', 'big bazaar', 'dmart', 'walmart'],
+                                'Transport': ['taxi', 'uber', 'ola', 'fuel', 'petrol', 'bus', 'train', 'airport', 'parking'],
+                                'Shopping': ['mall', 'store', 'shop', 'purchase', 'clothes', 'electronics', 'amazon', 'flipkart'],
+                                'Entertainment': ['movie', 'cinema', 'game', 'entertainment', 'theatre', 'netflix'],
+                                'Bills': ['electricity', 'water', 'internet', 'phone', 'rent', 'subscription', 'bill'],
+                                'Health': ['pharmacy', 'medicine', 'doctor', 'hospital', 'medical', 'apollo', 'apollo'],
+                                'Education': ['school', 'college', 'books', 'stationery', 'tution', 'course']
+                            }
+                            
+                            text_lower = extracted_text.lower()
+                            for cat, keywords in categories_keywords.items():
+                                if any(keyword in text_lower for keyword in keywords):
+                                    category = cat
+                                    break
                             
                             # Save to expenses with image data
                             image_data = f"data:image/png;base64,{base64.b64encode(uploaded_file.getvalue()).decode()}"
@@ -497,29 +420,30 @@ def ocr_receipt_processing():
                             
                             # Check budget alerts
                             check_budget_alerts(amount, category)
-                            
-                            # Generate financial insight for this expense
-                            generate_financial_insight_for_expense(new_expense.iloc[0])
-                            
                         else:
                             st.error("❌ Could not extract text from image. Please try a clearer image.")
+                            
                     except Exception as e:
                         st.error(f"❌ OCR processing failed: {str(e)}")
                         st.info("💡 Make sure Tesseract OCR is properly installed on your system")
+                
             except Exception as e:
                 st.error(f"❌ Error processing image: {str(e)}")
         else:
             st.info("📤 Please upload a receipt image (JPG, JPEG, PNG)")
+            
     except Exception as e:
         st.error(f"❌ Critical error in OCR processing: {str(e)}")
 
 def create_budget():
     """
     Function to create and manage budgets
-    LLM Needed: YES - For intelligent budget recommendations
+    LLM Needed: NO - Simple form-based input
+    Could use LLM for budget recommendations based on spending patterns
     """
     try:
         st.subheader("💰 Create Budget")
+        
         col1, col2 = st.columns(2)
         with col1:
             predefined_categories = ["Food", "Transport", "Shopping", "Entertainment", "Bills", "Health", "Education", "Other"]
@@ -528,45 +452,11 @@ def create_budget():
                 category = st.selectbox("Category", predefined_categories)
             else:
                 category = st.text_input("Enter custom category")
+        
         with col2:
             budget_amount = st.number_input("Budget Amount ($)", min_value=0.0, step=100.0, value=1000.0)
             period = st.selectbox("Period", ["Monthly", "Weekly", "Custom"])
         
-        # AI-powered budget recommendations
-        if st.button("🤖 Get AI Budget Recommendation"):
-            llm = get_llm()
-            if llm and not st.session_state.expenses.empty:
-                try:
-                    # Prepare spending history for LLM
-                    spending_summary = st.session_state.expenses.groupby('category')['amount'].sum().to_dict()
-                    spending_text = "\n".join([f"{cat}: ${amt:.2f}" for cat, amt in spending_summary.items()])
-                    
-                    prompt = f"""
-                    Based on this user's spending history:
-                    {spending_text}
-                    
-                    Suggest an optimal budget allocation for the category '{category}'.
-                    Consider typical spending patterns and financial best practices.
-                    Respond with a recommended budget amount in rupees.
-                    """
-                    
-                    response = llm.invoke([
-                        SystemMessage(content="You are a financial advisor that recommends optimal budget allocations."),
-                        HumanMessage(content=prompt)
-                    ])
-                    
-                    try:
-                        # Extract number from response
-                        recommendation = re.findall(r'\d+(?:\.\d+)?', response.content)
-                        if recommendation:
-                            recommended_amount = float(recommendation[0])
-                            st.info(f"🤖 AI Recommendation: ${recommended_amount:.2f} for {category}")
-                    except:
-                        st.info("🤖 AI Recommendation: " + response.content)
-                        
-                except Exception as e:
-                    st.error(f"Error getting AI recommendation: {str(e)}")
-        
         if st.button("📊 Set Budget"):
             if category and budget_amount > 0:
                 try:
@@ -574,6 +464,7 @@ def create_budget():
                     existing_budget = st.session_state.budgets[
                         st.session_state.budgets['category'] == category
                     ]
+                    
                     if not existing_budget.empty:
                         # Update existing budget
                         st.session_state.budgets.loc[
@@ -613,16 +504,19 @@ def create_budget():
                     st.success(f"✅ Budget for {budget_to_delete} deleted")
         else:
             st.info("📝 No budgets set yet. Create your first budget!")
+            
     except Exception as e:
         st.error(f"❌ Critical error in budget creation: {str(e)}")
 
 def set_savings_goals():
     """
     Function to set and track savings goals
-    LLM Needed: YES - For personalized savings recommendations
+    LLM Needed: NO - Simple goal tracking
+    Could use LLM for personalized savings recommendations
     """
     try:
         st.subheader("🎯 Savings Goals")
+        
         col1, col2, col3 = st.columns(3)
         with col1:
             goal_name = st.text_input("Goal Name", placeholder="e.g., Vacation, Emergency Fund")
@@ -632,40 +526,6 @@ def set_savings_goals():
             target_date = st.date_input("Target Date", 
                                       value=datetime.now() + timedelta(days=30))
         
-        # AI-powered savings goal recommendations
-        if st.button("🤖 Get AI Savings Recommendation"):
-            llm = get_llm()
-            if llm:
-                try:
-                    # Get user's financial situation
-                    total_income = st.session_state.budgets['budget_amount'].sum() if not st.session_state.budgets.empty else 0
-                    total_spending = st.session_state.expenses['amount'].sum() if not st.session_state.expenses.empty else 0
-                    current_savings = st.session_state.savings_goals['current_amount'].sum() if not st.session_state.savings_goals.empty else 0
-                    
-                    prompt = f"""
-                    Based on this financial situation:
-                    - Monthly income (budgeted): ${total_income:.2f}
-                    - Monthly spending: ${total_spending:.2f}
-                    - Current savings: ${current_savings:.2f}
-                    
-                    For a savings goal named '{goal_name}', suggest:
-                    1. A realistic target amount
-                    2. A reasonable timeline
-                    3. Weekly/monthly savings recommendations
-                    
-                    Keep response concise and actionable.
-                    """
-                    
-                    response = llm.invoke([
-                        SystemMessage(content="You are a financial advisor that recommends savings strategies."),
-                        HumanMessage(content=prompt)
-                    ])
-                    
-                    st.info("🤖 AI Savings Recommendation:\n" + response.content)
-                    
-                except Exception as e:
-                    st.error(f"Error getting AI recommendation: {str(e)}")
-        
         if st.button("🎯 Set Goal"):
             if goal_name and target_amount > 0:
                 try:
@@ -686,10 +546,12 @@ def set_savings_goals():
         # Display existing goals
         if not st.session_state.savings_goals.empty:
             st.subheader("🏆 Current Goals")
+            
             for idx, goal in st.session_state.savings_goals.iterrows():
                 try:
                     progress = (goal['current_amount'] / goal['target_amount']) * 100 if goal['target_amount'] > 0 else 0
                     days_left = (goal['target_date'] - datetime.now().date()).days
+                    
                     st.write(f"**{goal['goal_name']}**")
                     st.progress(min(progress/100, 1.0))
                     st.write(f"💰 ${goal['current_amount']:.2f} / ${goal['target_amount']:.2f} ({progress:.1f}%)")
@@ -703,21 +565,25 @@ def set_savings_goals():
                             st.session_state.savings_goals.at[idx, 'current_amount'] += add_amount
                             st.success(f"✅ Added ${add_amount:.2f} to {goal['goal_name']}")
                             st.rerun()
+                    
                     st.write("---")
                 except Exception as e:
                     st.error(f"❌ Error displaying goal: {str(e)}")
         else:
             st.info("📝 No savings goals set yet. Create your first goal!")
+            
     except Exception as e:
         st.error(f"❌ Critical error in savings goals: {str(e)}")
 
 def spending_categorization():
     """
     Function to categorize and review spending
-    LLM Needed: YES - For intelligent expense analysis
+    LLM Needed: NO - Rule-based categorization
+    Could use LLM for smarter automatic categorization
     """
     try:
         st.subheader("🏷️ Spending Categorization")
+        
         if not st.session_state.expenses.empty:
             # Display expenses that need categorization
             uncategorized = st.session_state.expenses[st.session_state.expenses['category'] == 'Other']
@@ -782,44 +648,14 @@ def spending_categorization():
                 total_spent = filtered_expenses['amount'].sum()
                 avg_spent = filtered_expenses['amount'].mean()
                 st.metric("Total Spent", f"${total_spent:.2f}")
+
                 st.metric("Average Expense", f"${avg_spent:.2f}")
-                
-                # AI-powered spending analysis
-                if st.button("🤖 Analyze Spending Patterns"):
-                    llm = get_llm()
-                    if llm:
-                        try:
-                            # Prepare spending data for analysis
-                            category_spending = filtered_expenses.groupby('category')['amount'].sum().to_dict()
-                            spending_text = "\n".join([f"{cat}: ${amt:.2f}" for cat, amt in category_spending.items()])
-                            
-                            prompt = f"""
-                            Analyze this spending pattern and provide insights:
-                            {spending_text}
-                            
-                            Please provide:
-                            1. Which categories are the highest spending?
-                            2. Any concerning spending patterns?
-                            3. Recommendations to optimize spending
-                            4. Potential savings opportunities
-                            
-                            Keep response concise and actionable.
-                            """
-                            
-                            with st.spinner("Analyzing spending patterns..."):
-                                response = llm.invoke([
-                                    SystemMessage(content="You are a financial analyst that provides spending insights."),
-                                    HumanMessage(content=prompt)
-                                ])
-                                
-                                st.info("🤖 Spending Analysis:\n" + response.content)
-                                
-                        except Exception as e:
-                            st.error(f"Error analyzing spending: {str(e)}")
+
             else:
                 st.info("🔍 No expenses match the current filters")
         else:
             st.info("📝 No expenses recorded yet. Start by adding expenses through voice or receipt scanning!")
+            
     except Exception as e:
         st.error(f"❌ Critical error in spending categorization: {str(e)}")
 
@@ -838,45 +674,24 @@ def check_budget_alerts(amount, category):
                 
                 if current_spending > budget_amount:
                     alert_msg = f"🚨 OVERSPENT: {category} - ${current_spending:.2f}/${budget_amount:.2f}"
+
+
                     if alert_msg not in st.session_state.notifications:
                         st.session_state.notifications.append(alert_msg)
                 elif current_spending > budget_amount * 0.8:  # 80% threshold
                     alert_msg = f"⚠️ WARNING: {category} - ${current_spending:.2f}/${budget_amount:.2f} ({((current_spending/budget_amount)*100):.1f}%)"
+
+
                     if alert_msg not in st.session_state.notifications:
                         st.session_state.notifications.append(alert_msg)
     except Exception as e:
         st.error(f"❌ Error checking budget alerts: {str(e)}")
 
-def generate_financial_insight_for_expense(expense):
-    """Generate AI-powered insight for a new expense"""
-    try:
-        llm = get_llm()
-        if llm:
-            prompt = f"""
-            For this expense:
-            - Amount: ${expense['amount']:.2f}
-            - Category: {expense['category']}
-            - Description: {expense['description']}
-            
-            Provide a brief, helpful insight or tip related to this type of spending.
-            Keep it under 100 words and make it actionable.
-            """
-            
-            response = llm.invoke([
-                SystemMessage(content="You are a financial advisor providing personalized spending insights."),
-                HumanMessage(content=prompt)
-            ])
-            
-            insight = f"💡 Insight for {expense['category']}: {response.content}"
-            st.session_state.financial_insights.append(insight)
-            
-    except Exception as e:
-        pass  # Silently fail if insight generation fails
-
 def alerts_and_notifications():
     """
     Function to check and display budget alerts
-    LLM Needed: YES - For personalized alert messages
+    LLM Needed: NO - Simple threshold checking
+    Could use LLM for personalized alert messages
     """
     try:
         st.subheader("🔔 Budget Alerts & Notifications")
@@ -892,16 +707,22 @@ def alerts_and_notifications():
             try:
                 # Calculate spending by category
                 spending_by_category = st.session_state.expenses.groupby('category')['amount'].sum().reset_index()
+                
                 alerts = []
                 for _, budget in st.session_state.budgets.iterrows():
                     category_spending = spending_by_category[spending_by_category['category'] == budget['category']]
                     if not category_spending.empty:
                         spent = category_spending.iloc[0]['amount']
                         budget_amount = budget['budget_amount']
+                        
                         if spent > budget_amount:
                             alerts.append(f"🚨 OVERSPENT: {budget['category']} - ${spent:.2f}/${budget_amount:.2f} ({((spent/budget_amount)*100):.1f}%)")
+
+
                         elif spent > budget_amount * 0.8:  # 80% threshold
                             alerts.append(f"⚠️ WARNING: {budget['category']} - ${spent:.2f}/${budget_amount:.2f} ({((spent/budget_amount)*100):.1f}%)")
+
+
                 
                 # Display alerts
                 if alerts:
@@ -911,6 +732,7 @@ def alerts_and_notifications():
                             st.session_state.notifications.append(alert)
                 else:
                     st.success("✅ All budgets are within limits!")
+                    
             except Exception as e:
                 st.error(f"❌ Error calculating alerts: {str(e)}")
         else:
@@ -924,26 +746,25 @@ def alerts_and_notifications():
         else:
             st.info("📭 No notifications yet")
             
-        # Display AI-generated financial insights
-        if st.session_state.financial_insights:
-            st.subheader("💡 Financial Insights")
-            for insight in reversed(st.session_state.financial_insights[-5:]):  # Show last 5
-                st.info(insight)
     except Exception as e:
         st.error(f"❌ Critical error in alerts system: {str(e)}")
 
 def visualizations_and_summaries():
     """
     Function to create charts and summaries
-    LLM Needed: YES - For intelligent financial summaries
+    LLM Needed: NO - Standard data visualization
+    Could use LLM for generating insights and summaries
     """
     try:
         st.subheader("📊 Financial Visualizations")
+        
         if not st.session_state.expenses.empty:
             try:
                 # Spending by category pie chart
                 spending_by_category = st.session_state.expenses.groupby('category')['amount'].sum()
+                
                 col1, col2 = st.columns(2)
+                
                 with col1:
                     st.write("💰 Spending by Category")
                     if len(spending_by_category) > 0:
@@ -952,6 +773,7 @@ def visualizations_and_summaries():
                         st.plotly_chart(fig1, use_container_width=True)
                     else:
                         st.info("No spending data to visualize")
+                
                 with col2:
                     st.write("📈 Spending Trend")
                     daily_spending = st.session_state.expenses.groupby('date')['amount'].sum().reset_index()
@@ -969,17 +791,21 @@ def visualizations_and_summaries():
                 monthly_expenses = st.session_state.expenses[
                     st.session_state.expenses['date'].str.startswith(current_month)
                 ]
+                
                 if not monthly_expenses.empty:
                     total_spent = monthly_expenses['amount'].sum()
                     st.metric("Total Monthly Spending", f"${total_spent:.2f}")
+
+                    
                     category_summary = monthly_expenses.groupby('category')['amount'].sum().reset_index()
                     fig3 = px.bar(category_summary, x='category', y='amount', 
                                 title='Monthly Spending by Category')
                     st.plotly_chart(fig3, use_container_width=True)
+                    
                     st.dataframe(category_summary)
                 else:
                     st.info("No expenses recorded this month.")
-                
+                    
                 # Budget vs Actual comparison
                 if not st.session_state.budgets.empty:
                     st.subheader("⚖️ Budget vs Actual Comparison")
@@ -994,76 +820,35 @@ def visualizations_and_summaries():
                             'Actual': actual_spent,
                             'Difference': budget['budget_amount'] - actual_spent
                         })
+                    
                     if budget_comparison:
                         comparison_df = pd.DataFrame(budget_comparison)
                         st.dataframe(comparison_df)
+                        
                         # Visualization
                         fig4 = go.Figure()
                         fig4.add_trace(go.Bar(name='Budget', x=comparison_df['Category'], y=comparison_df['Budget']))
                         fig4.add_trace(go.Bar(name='Actual', x=comparison_df['Category'], y=comparison_df['Actual']))
                         fig4.update_layout(title="Budget vs Actual Spending", barmode='group')
                         st.plotly_chart(fig4, use_container_width=True)
-                
-                # AI-powered financial summary
-                if st.button("🤖 Generate Financial Summary"):
-                    llm = get_llm()
-                    if llm:
-                        try:
-                            # Prepare data for summary
-                            total_expenses = st.session_state.expenses['amount'].sum()
-                            category_spending = st.session_state.expenses.groupby('category')['amount'].sum().to_dict()
-                            spending_text = "\n".join([f"{cat}: ${amt:.2f}" for cat, amt in category_spending.items()])
-                            
-                            # Get budget data
-                            total_budget = st.session_state.budgets['budget_amount'].sum()
-                            budget_text = "\n".join([f"{row['category']}: ${row['budget_amount']:.2f}" 
-                                                   for _, row in st.session_state.budgets.iterrows()])
-                            
-                            prompt = f"""
-                            Based on this financial data:
-                            
-                            Total Expenses: ${total_expenses:.2f}
-                            
-                            Spending by Category:
-                            {spending_text}
-                            
-                            Budget Allocations:
-                            {budget_text if budget_text else "No budgets set"}
-                            
-                            Please provide:
-                            1. Overall financial health assessment
-                            2. Top 3 spending categories and insights
-                            3. Budget adherence analysis (if budgets exist)
-                            4. Personalized recommendations for improvement
-                            
-                            Keep response concise, structured, and actionable.
-                            """
-                            
-                            with st.spinner("Generating financial summary..."):
-                                response = llm.invoke([
-                                    SystemMessage(content="You are a financial advisor providing comprehensive financial summaries."),
-                                    HumanMessage(content=prompt)
-                                ])
-                                
-                                st.info("🤖 Financial Summary:\n" + response.content)
-                                
-                        except Exception as e:
-                            st.error(f"Error generating summary: {str(e)}")
-                            
+                    
             except Exception as e:
                 st.error(f"❌ Error creating visualizations: {str(e)}")
         else:
             st.info("📝 No data to visualize yet. Start by recording expenses!")
+            
     except Exception as e:
         st.error(f"❌ Critical error in visualizations: {str(e)}")
 
 def receipt_management():
     """
     Function to manage and view stored receipts
-    LLM Needed: YES - For receipt analysis and insights
+    LLM Needed: NO - Simple storage and retrieval
+    Could use LLM for receipt categorization and insights
     """
     try:
         st.subheader("🧾 Receipt Management")
+        
         if not st.session_state.expenses.empty:
             receipts = st.session_state.expenses[st.session_state.expenses['receipt_image'] != '']
             if not receipts.empty:
@@ -1098,40 +883,12 @@ def receipt_management():
                             with cols[idx % 3]:
                                 st.write(f"**📅 {receipt['date']}**")
                                 st.write(f"💰 ${receipt['amount']:.2f}")
+
                                 st.write(f"🏷️ {receipt['category']}")
                                 if receipt['receipt_image'].startswith('data:image'):
                                     # Display base64 image
                                     st.image(receipt['receipt_image'], width=200)
                                 st.write(f"📝 {receipt['description'][:50]}...")
-                                
-                                # AI-powered receipt analysis
-                                if st.button("🤖 Analyze Receipt", key=f"analyze_{idx}"):
-                                    llm = get_llm()
-                                    if llm:
-                                        try:
-                                            prompt = f"""
-                                            Analyze this receipt expense:
-                                            - Amount: ${receipt['amount']:.2f}
-                                            - Category: {receipt['category']}
-                                            - Date: {receipt['date']}
-                                            
-                                            Provide insights on:
-                                            1. Whether this is a typical expense for this category
-                                            2. Spending patterns related to this type of purchase
-                                            3. Tips to optimize similar expenses
-                                            
-                                            Keep response concise and actionable.
-                                            """
-                                            
-                                            response = llm.invoke([
-                                                SystemMessage(content="You are a financial advisor analyzing individual receipts."),
-                                                HumanMessage(content=prompt)
-                                            ])
-                                            
-                                            st.info("🤖 Receipt Analysis:\n" + response.content)
-                                            
-                                        except Exception as e:
-                                            st.error(f"Error analyzing receipt: {str(e)}")
                                 st.write("---")
                         except Exception as e:
                             st.error(f"❌ Error displaying receipt: {str(e)}")
@@ -1141,6 +898,7 @@ def receipt_management():
                 st.info("📝 No receipts uploaded yet. Upload receipts through the OCR feature!")
         else:
             st.info("📝 No expenses recorded yet. Start by recording expenses!")
+            
     except Exception as e:
         st.error(f"❌ Critical error in receipt management: {str(e)}")
 
@@ -1151,13 +909,16 @@ def data_security_and_privacy():
     """
     try:
         st.subheader("🔒 Data Security & Privacy")
+        
         st.write("🛡️ Your financial data is stored locally and never shared with third parties.")
         st.write("🔐 All data is encrypted and protected according to privacy regulations.")
         
         # Security settings
         st.subheader("⚙️ Security Settings")
+        
         if st.checkbox("Enable Data Encryption", value=True):
             st.success("✅ Data encryption is enabled!")
+        
         if st.checkbox("Enable Automatic Backups"):
             backup_frequency = st.selectbox("Backup Frequency", ["Daily", "Weekly", "Monthly"])
             st.info(f"📅 Automatic backups will run {backup_frequency.lower()}")
@@ -1171,6 +932,7 @@ def data_security_and_privacy():
                     'budgets': st.session_state.budgets.to_dict('records') if not st.session_state.budgets.empty else [],
                     'savings_goals': st.session_state.savings_goals.to_dict('records') if not st.session_state.savings_goals.empty else []
                 }
+                
                 json_str = json.dumps(export_data, indent=2, default=str)
                 st.download_button(
                     label="📥 Download Data as JSON",
@@ -1178,6 +940,7 @@ def data_security_and_privacy():
                     file_name=f"budget_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
                     mime="application/json"
                 )
+                
                 # Also provide CSV export
                 if not st.session_state.expenses.empty:
                     st.download_button(
@@ -1197,73 +960,55 @@ def data_security_and_privacy():
             - We collect only the financial data you enter
             - No personal identification information is collected
             - All data is stored locally on your device
+            
             **Data Usage:**
             - Your data is used only for the functionality of this application
             - We do not share your data with any third parties
             - Data is not transmitted over the internet
+            
             **Data Security:**
             - All data is encrypted at rest
             - You have full control over your data
             - You can export or delete your data at any time
             """)
+            
     except Exception as e:
         st.error(f"❌ Critical error in security section: {str(e)}")
 
 def bank_integration_placeholder():
     """
     Placeholder for bank integration feature
-    LLM Needed: YES - For natural language banking queries
+    LLM Needed: NO - Just UI placeholder
+    Would need LLM for natural language banking queries
     """
     try:
         st.subheader("🏦 Bank Integration (Coming Soon)")
+        
         st.info("🚀 This feature will allow automatic syncing with your bank accounts!")
+        
         st.write("📋 Planned Features:")
         st.write("• Automatic transaction import")
         st.write("• Real-time balance updates")
         st.write("• Bank statement analysis")
         st.write("• Automatic expense categorization")
         
-        # AI-powered banking assistant
-        st.subheader("🤖 AI Banking Assistant (Preview)")
-        user_query = st.text_input("Ask about banking features:")
-        if user_query and st.button("Get Answer"):
-            llm = get_llm()
-            if llm:
-                try:
-                    prompt = f"""
-                    User wants to know about: {user_query}
-                    
-                    This is a budget tracking application that will integrate with banks.
-                    Explain how this feature would work and its benefits.
-                    Keep response helpful and informative.
-                    """
-                    
-                    response = llm.invoke([
-                        SystemMessage(content="You are a banking technology expert explaining features."),
-                        HumanMessage(content=prompt)
-                    ])
-                    
-                    st.info(response.content)
-                    
-                except Exception as e:
-                    st.error(f"Error processing query: {str(e)}")
-        
         bank_name = st.selectbox("Select Bank", ["HDFC", "ICICI", "SBI", "Axis", "Kotak", "Other"])
         if bank_name:
             st.info(f"Bank integration for {bank_name} will be available soon!")
+            
     except Exception as e:
         st.error(f"❌ Error in bank integration section: {str(e)}")
 
 def main_dashboard():
     """
     Main dashboard overview
-    LLM Needed: YES - For financial health score and insights
     """
     try:
         st.subheader("🏠 Dashboard Overview")
         
         # Key metrics
         col1, col2, col3, col4 = st.columns(4)
+        
         total_expenses = st.session_state.expenses['amount'].sum() if not st.session_state.expenses.empty else 0
         total_budget = st.session_state.budgets['budget_amount'].sum() if not st.session_state.budgets.empty else 0
         total_savings = st.session_state.savings_goals['current_amount'].sum() if not st.session_state.savings_goals.empty else 0
@@ -1271,10 +1016,13 @@ def main_dashboard():
         
         with col1:
             st.metric("💰 Total Expenses", f"${total_expenses:.2f}")
+
         with col2:
             st.metric("📊 Total Budget", f"${total_budget:.2f}")
+
         with col3:
             st.metric("🏆 Total Savings", f"${total_savings:.2f}")
+
         with col4:
             st.metric("🧾 Expense Count", f"{expense_count}")
         
@@ -1309,10 +1057,13 @@ def main_dashboard():
                 category_spending = st.session_state.expenses[
                     st.session_state.expenses['category'] == budget['category']
                 ]['amount'].sum()
+                
                 progress = (category_spending / budget['budget_amount']) * 100 if budget['budget_amount'] > 0 else 0
                 st.write(f"**{budget['category']}**")
                 st.progress(min(progress/100, 1.0))
                 st.write(f"${category_spending:.2f} / ${budget['budget_amount']:.2f} ({progress:.1f}%)")
+
+
         
         # Savings goals progress
         if not st.session_state.savings_goals.empty:
@@ -1322,54 +1073,9 @@ def main_dashboard():
                 st.write(f"**{goal['goal_name']}**")
                 st.progress(min(progress/100, 1.0))
                 st.write(f"${goal['current_amount']:.2f} / ${goal['target_amount']:.2f} ({progress:.1f}%)")
+
+
         
-        # AI-powered financial health score
-        if st.button("🤖 Calculate Financial Health Score"):
-            llm = get_llm()
-            if llm and not st.session_state.expenses.empty:
-                try:
-                    # Prepare financial data
-                    total_income = total_budget
-                    total_spent = total_expenses
-                    savings_rate = (total_savings / total_income * 100) if total_income > 0 else 0
-                    
-                    # Category diversity (more categories = better)
-                    category_count = len(st.session_state.expenses['category'].unique())
-                    
-                    prompt = f"""
-                    Calculate a financial health score (0-100) based on:
-                    - Total income/budget: ${total_income:.2f}
-                    - Total spending: ${total_spent:.2f}
-                    - Savings amount: ${total_savings:.2f}
-                    - Savings rate: {savings_rate:.1f}%
-                    - Spending category diversity: {category_count} categories
-                    
-                    Consider:
-                    1. Spending vs income ratio
-                    2. Savings rate
-                    3. Budget adherence
-                    4. Spending diversity
-                    5. Financial stability indicators
-                    
-                    Provide:
-                    1. Score out of 100
-                    2. Brief explanation of the score
-                    3. Top 3 improvement recommendations
-                    
-                    Keep response concise and actionable.
-                    """
-                    
-                    with st.spinner("Calculating financial health score..."):
-                        response = llm.invoke([
-                            SystemMessage(content="You are a financial health assessment expert."),
-                            HumanMessage(content=prompt)
-                        ])
-                        
-                        st.info("🤖 Financial Health Assessment:\n" + response.content)
-                        
-                except Exception as e:
-                    st.error(f"Error calculating health score: {str(e)}")
-                    
     except Exception as e:
         st.error(f"❌ Error in dashboard: {str(e)}")
 
@@ -1411,7 +1117,7 @@ def main():
         
         # App title and description
         st.title("💰 Budget Tracker Pro")
-        st.markdown("*Your intelligent personal finance assistant powered by AI*")
+        st.markdown("*Your intelligent personal finance assistant*")
         
         # Sidebar navigation
         st.sidebar.title("🧭 Navigation")
@@ -1476,20 +1182,9 @@ def main():
         st.sidebar.markdown("---")
         st.sidebar.info("💡 Tip: Use voice commands for quick expense logging!")
         
-        # Initialize LLM on startup
-        if 'llm_initialized' not in st.session_state:
-            with st.sidebar:
-                with st.spinner("Initializing AI assistant..."):
-                    llm = get_llm()
-                    if llm:
-                        st.session_state.llm_initialized = True
-                        st.success("🤖 AI assistant ready!")
-                    else:
-                        st.warning("⚠️ AI features disabled - check Groq API key")
-        
     except Exception as e:
         st.error(f"❌ Critical application error: {str(e)}")
         st.info("🔄 Please refresh the page or contact support if the issue persists.")
 
 if __name__ == "__main__":
-    main()
+    main()