Initial Commit

README.md

@@ -12,3 +12,187 @@ short_description: Finance MCP to Analyze Finance Statement (Email, PDF)
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Spend Analyzer MCP
+
+A comprehensive financial analysis tool that processes bank statements from emails or uploaded PDFs, analyzes spending patterns, and provides AI-powered financial insights through a Model Context Protocol (MCP) interface.
+
+## Features
+
+- **📧 Email Processing**: Automatically fetch and process bank statements from your email
+- **📄 PDF Upload**: Direct upload and analysis of bank statement PDFs
+- **📊 Analysis Dashboard**: Interactive charts and financial summaries
+- **🤖 AI Financial Advisor**: Chat with Claude for personalized financial advice
+- **⚙️ Settings & Configuration**: Customize budgets, email settings, and export options
+- **🔐 Security**: Password-protected PDF support and secure email connections
+
+## Architecture
+
+The project consists of several key components:
+
+1. **`gradio_interface.py`** - Main web interface built with Gradio
+2. **`spend_analyzer.py`** - Core financial analysis engine
+3. **`email_processor.py`** - Email and PDF processing functionality
+4. **`modal_deployment.py`** - Modal.com cloud deployment configuration
+5. **`mcp_server.py`** - Model Context Protocol server implementation
+
+## Installation
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Set up environment variables:
+```bash
+# Create .env file
+ANTHROPIC_API_KEY=your_claude_api_key
+[email protected]
+EMAIL_PASS=your_app_password
+IMAP_SERVER=imap.gmail.com
+```
+
+3. For Modal deployment (optional):
+```bash
+modal token new
+modal deploy modal_deployment.py
+```
+
+## Usage
+
+### Local Development
+
+Run the Gradio interface locally:
+```bash
+python gradio_interface.py
+```
+
+The interface will be available at `http://localhost:7860`
+
+### Features Overview
+
+#### Email Processing Tab
+- Connect to Gmail, Outlook, or Yahoo email
+- Automatically scan for bank statement PDFs
+- Handle password-protected documents
+- Process statements from the last 7-90 days
+
+#### PDF Upload Tab
+- Direct upload of bank statement PDFs
+- Support for multiple files
+- Password protection handling
+- Instant analysis and processing
+
+#### Analysis Dashboard
+- Financial summary cards (income, expenses, cash flow)
+- Interactive spending category charts
+- Monthly trend analysis
+- Budget alerts and recommendations
+- Detailed transaction tables
+
+#### AI Financial Advisor
+- Chat with Claude about your spending patterns
+- Quick question buttons for common queries
+- Contextual responses based on your data
+- Personalized financial recommendations
+
+#### Settings
+- **Budget Settings**: Set monthly limits by category
+- **Email Settings**: Configure email providers and auto-processing
+- **Export Settings**: Choose data export formats (JSON, CSV, Excel)
+
+## MCP Integration
+
+This project implements the Model Context Protocol (MCP) for integration with Claude and other AI systems:
+
+- **Tools**: Process statements, analyze PDFs, get AI insights
+- **Resources**: Access financial data and analysis results
+- **Server**: Full MCP server implementation for external integrations
+
+## Security Considerations
+
+- Email passwords should use app-specific passwords
+- PDF passwords are handled securely in memory
+- No financial data is stored permanently by default
+- All processing can be done locally or in secure cloud environments
+
+## Development
+
+### Project Structure
+```
+spend-analyzer-mcp/
+├── gradio_interface.py      # Main web interface
+├── spend_analyzer.py        # Financial analysis engine
+├── email_processor.py       # Email/PDF processing
+├── modal_deployment.py      # Cloud deployment
+├── mcp_server.py           # MCP protocol server
+├── requirements.txt        # Dependencies
+└── README.md              # This file
+```
+
+### Key Classes
+
+- **`SpendAnalyzerInterface`**: Main Gradio interface controller
+- **`SpendAnalyzer`**: Core financial analysis and insights
+- **`EmailProcessor`**: Email connection and PDF extraction
+- **`PDFProcessor`**: Bank statement PDF parsing
+- **`MCPServer`**: Model Context Protocol implementation
+
+### Extending the System
+
+1. **Add New Banks**: Extend parsing patterns in `PDFProcessor`
+2. **Custom Categories**: Modify categorization logic in `SpendAnalyzer`
+3. **New Charts**: Add visualization functions to the dashboard
+4. **AI Prompts**: Enhance Claude integration in `modal_deployment.py`
+
+## Deployment Options
+
+### Local Deployment
+- Run directly with Python
+- All processing happens locally
+- Suitable for development and testing
+
+### Modal.com Deployment
+- Serverless cloud deployment
+- Scalable processing
+- Integrated with Claude API
+- Production-ready
+
+### Docker Deployment
+```dockerfile
+FROM python:3.11-slim
+COPY . /app
+WORKDIR /app
+RUN pip install -r requirements.txt
+EXPOSE 7860
+CMD ["python", "gradio_interface.py"]
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## License
+
+This project is open source. Please ensure you comply with your bank's terms of service when processing financial data.
+
+## Support
+
+For issues and questions:
+1. Check the existing issues
+2. Create a new issue with detailed information
+3. Include error logs and system information
+
+## Roadmap
+
+- [ ] Support for more bank formats
+- [ ] Real-time transaction monitoring
+- [ ] Mobile app interface
+- [ ] Advanced ML-based categorization
+- [ ] Integration with financial planning tools
+- [ ] Multi-currency support
+- [ ] Automated bill tracking

email_processor.py

@@ -0,0 +1,369 @@
+"""
+Email and PDF Processing Module for Bank Statement Analysis
+"""
+import imaplib
+from email.message import Message
+import os
+import io
+import re
+import pandas as pd
+from typing import List, Dict, Optional, Tuple
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+import PyPDF2
+import fitz  # PyMuPDF
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+import logging
+
+@dataclass
+class BankTransaction:
+    date: datetime
+    description: str
+    amount: float
+    category: str = "Unknown"
+    account: str = ""
+    balance: Optional[float] = None
+
+@dataclass
+class StatementInfo:
+    bank_name: str
+    account_number: str
+    statement_period: str
+    transactions: List[BankTransaction]
+    opening_balance: float
+    closing_balance: float
+
+class EmailProcessor:
+    def __init__(self, email_config: Dict):
+        self.email_config = email_config
+        self.logger = logging.getLogger(__name__)
+        self.bank_patterns = {
+            'chase': r'chase\.com|jpmorgan',
+            'bofa': r'bankofamerica\.com|bofa',
+            'wells': r'wellsfargo\.com',
+            'citi': r'citi\.com|citibank',
+            'amex': r'americanexpress\.com|amex',
+            'hdfc': r'hdfcbank\.com',
+            'icici': r'icicibank\.com',
+            'sbi': r'sbi\.co\.in',
+            'axis': r'axisbank\.com',
+        }
+
+    async def connect_to_email(self) -> imaplib.IMAP4_SSL:
+        """Connect to email server"""
+        try:
+            mail = imaplib.IMAP4_SSL(self.email_config['imap_server'])
+            mail.login(self.email_config['email'], self.email_config['password'])
+            return mail
+        except Exception as e:
+            self.logger.error(f"Failed to connect to email: {e}")
+            raise
+
+    async def fetch_bank_emails(self, days_back: int = 30) -> List[Message]:
+        """Fetch emails from banks containing statements"""
+        mail = await self.connect_to_email()
+        mail.select('inbox')
+
+        # Calculate date range
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_back)
+
+        # Search for bank emails
+        bank_domains = '|'.join(self.bank_patterns.values())
+        search_criteria = f'(FROM "{bank_domains}" SINCE "{start_date.strftime("%d-%b-%Y")}")'
+
+        try:
+            status, messages = mail.search(None, search_criteria)
+            email_ids = messages[0].split()
+
+            emails = []
+            for email_id in email_ids[-50:]:  # Limit to recent 50 emails
+                status, msg_data = mail.fetch(email_id, '(RFC822)')
+                msg = Message.from_bytes(msg_data[0][1])
+                emails.append(msg)
+
+            return emails
+        finally:
+            mail.close()
+            mail.logout()
+
+    def identify_bank(self, sender_email: str) -> str:
+        """Identify bank from sender email"""
+        sender_lower = sender_email.lower()
+        for bank, pattern in self.bank_patterns.items():
+            if re.search(pattern, sender_lower):
+                return bank
+        return "unknown"
+
+    async def extract_attachments(self, msg: Message) -> List[Tuple[str, bytes, str]]:
+        """Extract PDF attachments from email"""
+        attachments = []
+        self.logger.debug(f"Processing message with type: {type(msg)}")
+
+        for part in msg.walk():
+            self.logger.debug(f"Processing part with type: {type(part)}")
+            try:
+                if part.get_content_disposition() == 'attachment':
+                    filename = part.get_filename()
+                    if filename and filename.lower().endswith('.pdf'):
+                        content = part.get_payload(decode=True)
+                        attachments.append((filename, content, 'pdf'))
+            except Exception as e:
+                self.logger.error(f"Error processing part: {e}, Part type: {type(part)}")
+                continue
+
+        return attachments
+
+class PDFProcessor:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.transaction_patterns = {
+            'date': r'(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})',
+            'amount': r'([\$\-]?[\d,]+\.?\d{0,2})',
+            'description': r'([A-Za-z0-9\s\*\#\-_]+)'
+        }
+
+    async def process_pdf(self, pdf_content: bytes, password: Optional[str] = None) -> StatementInfo:
+        """Process PDF bank statement"""
+        try:
+            # Try PyMuPDF first
+            doc = fitz.open(stream=pdf_content, filetype="pdf")
+
+            if doc.needs_pass and password:
+                if not doc.authenticate(password):
+                    raise ValueError("Invalid PDF password")
+            elif doc.needs_pass and not password:
+                raise ValueError("PDF requires password")
+
+            text = ""
+            for page in doc:
+                text += page.get_text()
+
+            doc.close()
+
+            return await self.parse_statement_text(text)
+
+        except Exception as e:
+            self.logger.error(f"Error processing PDF: {e}")
+            # Fallback to PyPDF2
+            return await self.process_pdf_fallback(pdf_content, password)
+
+    async def process_pdf_fallback(self, pdf_content: bytes, password: Optional[str] = None) -> StatementInfo:
+        """Fallback PDF processing with PyPDF2"""
+        try:
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_content))
+
+            if pdf_reader.is_encrypted:
+                if password:
+                    pdf_reader.decrypt(password)
+                else:
+                    raise ValueError("PDF requires password")
+
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text()
+
+            return await self.parse_statement_text(text)
+
+        except Exception as e:
+            self.logger.error(f"Fallback PDF processing failed: {e}")
+            raise
+
+    async def parse_statement_text(self, text: str) -> StatementInfo:
+        """Parse bank statement text to extract transactions"""
+        lines = text.split('\n')
+        transactions = []
+
+        # Bank-specific parsing logic
+        bank_name = self.detect_bank_from_text(text)
+        account_number = self.extract_account_number(text)
+        statement_period = self.extract_statement_period(text)
+
+        # Extract transactions based on patterns
+        for line in lines:
+            transaction = self.parse_transaction_line(line)
+            if transaction:
+                transactions.append(transaction)
+
+        # Extract balances
+        opening_balance = self.extract_opening_balance(text)
+        closing_balance = self.extract_closing_balance(text)
+
+        return StatementInfo(
+            bank_name=bank_name,
+            account_number=account_number,
+            statement_period=statement_period,
+            transactions=transactions,
+            opening_balance=opening_balance,
+            closing_balance=closing_balance
+        )
+
+    def detect_bank_from_text(self, text: str) -> str:
+        """Detect bank from statement text"""
+        text_lower = text.lower()
+        if 'chase' in text_lower or 'jpmorgan' in text_lower:
+            return 'Chase'
+        elif 'bank of america' in text_lower or 'bofa' in text_lower:
+            return 'Bank of America'
+        elif 'wells fargo' in text_lower:
+            return 'Wells Fargo'
+        elif 'citibank' in text_lower or 'citi' in text_lower:
+            return 'Citibank'
+        elif 'american express' in text_lower or 'amex' in text_lower:
+            return 'American Express'
+        return 'Unknown Bank'
+
+    def extract_account_number(self, text: str) -> str:
+        """Extract account number from statement"""
+        # Look for account number patterns
+        patterns = [
+            r'Account\s+(?:Number|#)?\s*:\s*(\*\+\d{4})',
+            r'Account\s+(\d{4,})',
+            r'(\*\+\d{4})'
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                return match.group(1)
+        return "Unknown"
+
+    def extract_statement_period(self, text: str) -> str:
+        """Extract statement period"""
+        # Look for date ranges
+        pattern = r'(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})\s*(?:to|through|-)\s*(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})'
+        match = re.search(pattern, text, re.IGNORECASE)
+
+        if match:
+            return f"{match.group(1)} to {match.group(2)}"
+        return "Unknown Period"
+
+    def parse_transaction_line(self, line: str) -> Optional[BankTransaction]:
+        """Parse individual transaction line"""
+        # Common transaction line patterns
+        patterns = [
+            # Date, Description, Amount
+            r'(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})\s+(.+?)\s+([\$\-]?[\d,]+\.?\d{0,2})$',
+            # Date, Amount, Description
+            r'(\d{1,2}[/-]\d{1,2}[/-]\d{2,4})\s+([\$\-]?[\d,]+\.?\d{0,2})\s+(.+)$'
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, line.strip())
+            if match:
+                try:
+                    date_str = match.group(1)
+                    if len(match.groups()) == 3:
+                        if '$' in match.group(2) or match.group(2).replace('-', '').replace('.', '').replace(',', '').isdigit():
+                            # Pattern: Date, Amount, Description
+                            amount_str = match.group(2)
+                            description = match.group(3)
+                        else:
+                            # Pattern: Date, Description, Amount
+                            description = match.group(2)
+                            amount_str = match.group(3)
+
+                    # Parse date
+                    transaction_date = self.parse_date(date_str)
+
+                    # Parse amount
+                    amount = self.parse_amount(amount_str)
+
+                    # Categorize transaction
+                    category = self.categorize_transaction(description)
+
+                    return BankTransaction(
+                        date=transaction_date,
+                        description=description.strip(),
+                        amount=amount,
+                        category=category
+                    )
+
+                except Exception as e:
+                    self.logger.debug(f"Failed to parse transaction line: {line}, Error: {e}")
+                    continue
+        return None
+
+    def parse_date(self, date_str: str) -> datetime:
+        """Parse date string to datetime object"""
+        # Try different date formats
+        formats = ['%m/%d/%Y', '%m-%d-%Y', '%m/%d/%y', '%m-%d-%y']
+
+        for fmt in formats:
+            try:
+                return datetime.strptime(date_str, fmt)
+            except ValueError:
+                continue
+        # If all fails, return current date
+        return datetime.now()
+
+    def parse_amount(self, amount_str: str) -> float:
+        """Parse amount string to float"""
+        # Clean amount string
+        clean_amount = amount_str.replace('$', '').replace(',', '').strip()
+
+        # Handle negative amounts
+        is_negative = clean_amount.startswith('-') or clean_amount.startswith('(')
+        clean_amount = clean_amount.replace('-', '').replace('(', '').replace(')', '')
+
+        try:
+            amount = float(clean_amount)
+            return -amount if is_negative else amount
+        except ValueError:
+            return 0.0
+
+    def categorize_transaction(self, description: str) -> str:
+        """Categorize transaction based on description"""
+        desc_lower = description.lower()
+
+        categories = {
+            'Food & Dining': ['restaurant', 'mcdonalds', 'starbucks', 'food', 'dining', 'cafe', 'pizza'],
+            'Shopping': ['amazon', 'walmart', 'target', 'shopping', 'store', 'retail'],
+            'Gas & Transport': ['shell', 'exxon', 'gas', 'fuel', 'uber', 'lyft', 'taxi'],
+            'Utilities': ['electric', 'water', 'gas bill', 'internet', 'phone', 'utility'],
+            'Entertainment': ['netflix', 'spotify', 'movie', 'entertainment', 'gaming'],
+            'Healthcare': ['pharmacy', 'doctor', 'hospital', 'medical', 'health'],
+            'Banking': ['atm', 'fee', 'interest', 'transfer', 'deposit']
+        }
+
+        for category, keywords in categories.items():
+            if any(keyword in desc_lower for keyword in keywords):
+                return category
+        return 'Other'
+
+    def extract_opening_balance(self, text: str) -> float:
+        """Extract opening balance from statement"""
+        patterns = [
+            r'Beginning\s+Balance\s*:\s*\$?([\d,]+\.?\d{0,2})',
+            r'Opening\s+Balance\s*:\s*\$?([\d,]+\.?\d{0,2})',
+            r'Previous\s+Balance\s*:\s*\$?([\d,]+\.?\d{0,2})'
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                return float(match.group(1).replace(',', ''))
+        return 0.0
+
+    def extract_closing_balance(self, text: str) -> float:
+        """Extract closing balance from statement"""
+        patterns = [
+            r'Ending\s+Balance\s*:\s*\$?([\d,]+\.?\d{0,2})',
+            r'Closing\s+Balance\s*:\s*\$?([\d,]+\.?\d{0,2})',
+            r'Current\s+Balance\s*:\s*\$?([\d,]+\.?\d{0,2})'
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                return float(match.group(1).replace(',', ''))
+        return 0.0
+
+# Example usage
+if __name__ == "__main__":
+    # Test PDF processing
+    pdf_processor = PDFProcessor()
+
+    # Example test with sample PDF content
+    print("PDF Processor initialized successfully")

gradio_interface.py

@@ -0,0 +1,788 @@
+"""
+Gradio Web Interface for Spend Analyzer MCP
+"""
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import json
+import os
+from typing import Dict, List, Optional, Tuple
+import asyncio
+from datetime import datetime, timedelta
+import modal
+import logging
+
+# Import our Modal functions
+from modal_deployment import (
+    process_bank_statements,
+    analyze_uploaded_statements, 
+    get_claude_analysis,
+    save_user_data,
+    load_user_data
+)
+
+class SpendAnalyzerInterface:
+    def __init__(self):
+        self.current_analysis = None
+        self.user_sessions = {}
+        self.logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.INFO)
+        
+    def create_interface(self):
+        """Create the main Gradio interface"""
+        
+        with gr.Blocks(
+            title="Spend Analyzer MCP",
+            theme=gr.themes.Soft(),
+            css="""
+            .main-header { text-align: center; margin: 20px 0; }
+            .status-box { padding: 10px; border-radius: 5px; margin: 10px 0; }
+            .success-box { background-color: #d4edda; border: 1px solid #c3e6cb; }
+            .error-box { background-color: #f8d7da; border: 1px solid #f5c6cb; }
+            .warning-box { background-color: #fff3cd; border: 1px solid #ffeaa7; }
+            """
+        ) as interface:
+            
+            gr.Markdown("# 💰 Spend Analyzer MCP", elem_classes=["main-header"])
+            gr.Markdown("*Analyze your bank statements with AI-powered insights*")
+            
+            with gr.Tabs():
+                # Tab 1: Email Processing
+                with gr.TabItem("📧 Email Processing"):
+                    self._create_email_tab()
+                
+                # Tab 2: PDF Upload
+                with gr.TabItem("📄 PDF Upload"):
+                    self._create_pdf_tab()
+                
+                # Tab 3: Analysis Dashboard
+                with gr.TabItem("📊 Analysis Dashboard"):
+                    self._create_dashboard_tab()
+                
+                # Tab 4: AI Chat
+                with gr.TabItem("🤖 AI Financial Advisor"):
+                    self._create_chat_tab()
+                
+                # Tab 5: Settings
+                with gr.TabItem("⚙️ Settings"):
+                    self._create_settings_tab()
+        
+        return interface
+    
+    def _create_email_tab(self):
+        """Create email processing tab"""
+        gr.Markdown("## Connect Your Email to Analyze Bank Statements")
+        gr.Markdown("*Securely connect to your email to automatically process bank statements*")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                email_provider = gr.Dropdown(
+                    choices=["Gmail", "Outlook", "Yahoo", "Other"],
+                    label="Email Provider",
+                    value="Gmail"
+                )
+                
+                email_address = gr.Textbox(
+                    label="Email Address",
+                    placeholder="[email protected]"
+                )
+                
+                email_password = gr.Textbox(
+                    label="Password/App Password",
+                    type="password",
+                    placeholder="App-specific password recommended"
+                )
+                
+                days_back = gr.Slider(
+                    minimum=7,
+                    maximum=90,
+                    value=30,
+                    step=1,
+                    label="Days to Look Back"
+                )
+                
+                process_email_btn = gr.Button("🔍 Process Email Statements", variant="primary")
+            
+            with gr.Column(scale=1):
+                email_status = gr.HTML()
+                
+                password_inputs = gr.Column(visible=False)
+                with password_inputs:
+                    gr.Markdown("### Password-Protected PDFs Found")
+                    pdf_passwords = gr.JSON(
+                        label="Enter passwords for protected files",
+                        value={}
+                    )
+                    retry_with_passwords = gr.Button("🔐 Retry with Passwords")
+        
+        email_results = gr.JSON(label="Processing Results", visible=False)
+        
+        # Event handlers
+        process_email_btn.click(
+            fn=self._process_email_statements,
+            inputs=[email_provider, email_address, email_password, days_back],
+            outputs=[email_status, email_results, password_inputs]
+        )
+        
+        retry_with_passwords.click(
+            fn=self._retry_with_passwords,
+            inputs=[email_provider, email_address, email_password, days_back, pdf_passwords],
+            outputs=[email_status, email_results]
+        )
+    
+    def _create_pdf_tab(self):
+        """Create PDF upload tab"""
+        gr.Markdown("## Upload Bank Statement PDFs")
+        gr.Markdown("*Upload your bank statement PDFs directly for analysis*")
+        
+        with gr.Row():
+            with gr.Column():
+                pdf_upload = gr.File(
+                    label="Upload Bank Statement PDFs",
+                    file_count="multiple",
+                    file_types=[".pdf"]
+                )
+                
+                pdf_passwords_input = gr.JSON(
+                    label="PDF Passwords (if needed)",
+                    placeholder='{"statement1.pdf": "password123"}',
+                    value={}
+                )
+                
+                analyze_pdf_btn = gr.Button("📊 Analyze PDFs", variant="primary")
+            
+            with gr.Column():
+                pdf_status = gr.HTML()
+                pdf_results = gr.JSON(label="Analysis Results", visible=False)
+        
+        # Event handler
+        analyze_pdf_btn.click(
+            fn=self._analyze_pdf_files,
+            inputs=[pdf_upload, pdf_passwords_input],
+            outputs=[pdf_status, pdf_results]
+        )
+    
+    def _create_dashboard_tab(self):
+        """Create analysis dashboard tab"""
+        gr.Markdown("## 📊 Financial Analysis Dashboard")
+        
+        with gr.Row():
+            refresh_btn = gr.Button("🔄 Refresh Dashboard")
+            export_btn = gr.Button("📤 Export Analysis")
+        
+        # Summary cards
+        with gr.Row():
+            total_income = gr.Number(label="Total Income", interactive=False)
+            total_expenses = gr.Number(label="Total Expenses", interactive=False)
+            net_cashflow = gr.Number(label="Net Cash Flow", interactive=False)
+            transaction_count = gr.Number(label="Total Transactions", interactive=False)
+        
+        # Charts
+        with gr.Row():
+            with gr.Column():
+                spending_by_category = gr.Plot(label="Spending by Category")
+                monthly_trends = gr.Plot(label="Monthly Trends")
+            
+            with gr.Column():
+                budget_alerts = gr.HTML(label="Budget Alerts")
+                recommendations = gr.HTML(label="Recommendations")
+        
+        # Detailed data
+        with gr.Accordion("Detailed Transaction Data", open=False):
+            transaction_table = gr.Dataframe(
+                headers=["Date", "Description", "Amount", "Category"],
+                interactive=False,
+                label="Recent Transactions"
+            )
+        
+        # Event handlers
+        refresh_btn.click(
+            fn=self._refresh_dashboard,
+            outputs=[total_income, total_expenses, net_cashflow, transaction_count,
+                    spending_by_category, monthly_trends, budget_alerts, recommendations,
+                    transaction_table]
+        )
+        
+        export_btn.click(
+            fn=self._export_analysis,
+            outputs=[gr.File(label="Analysis Export")]
+        )
+    
+    def _create_chat_tab(self):
+        """Create AI chat tab"""
+        gr.Markdown("## 🤖 AI Financial Advisor")
+        gr.Markdown("*Ask questions about your spending patterns and get personalized advice*")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(
+                    label="Financial Advisor Chat",
+                    height=400,
+                    show_label=True
+                )
+                
+                with gr.Row():
+                    msg_input = gr.Textbox(
+                        placeholder="Ask about your spending patterns, budgets, or financial goals...",
+                        label="Your Question",
+                        scale=4
+                    )
+                    send_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                # Quick question buttons
+                with gr.Row():
+                    gr.Button("💰 Budget Analysis", size="sm").click(
+                        lambda: "How am I doing with my budget this month?",
+                        outputs=[msg_input]
+                    )
+                    gr.Button("📈 Spending Trends", size="sm").click(
+                        lambda: "What are my spending trends over the last few months?",
+                        outputs=[msg_input]
+                    )
+                    gr.Button("💡 Save Money Tips", size="sm").click(
+                        lambda: "What are some specific ways I can save money based on my spending?",
+                        outputs=[msg_input]
+                    )
+                    gr.Button("🚨 Unusual Activity", size="sm").click(
+                        lambda: "Are there any unusual transactions I should be aware of?",
+                        outputs=[msg_input]
+                    )
+            
+            with gr.Column(scale=1):
+                chat_status = gr.HTML()
+                
+                # Analysis context
+                gr.Markdown("### Current Analysis Context")
+                context_info = gr.JSON(
+                    label="Available Data",
+                    value={"status": "No analysis loaded"}
+                )
+        
+        # Event handlers
+        send_btn.click(
+            fn=self._handle_chat_message,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input, chat_status]
+        )
+        
+        msg_input.submit(
+            fn=self._handle_chat_message,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input, chat_status]
+        )
+    
+    def _create_settings_tab(self):
+        """Create settings tab"""
+        gr.Markdown("## ⚙️ Settings & Configuration")
+        
+        with gr.Tabs():
+            with gr.TabItem("Budget Settings"):
+                gr.Markdown("### Set Monthly Budget Limits")
+                
+                with gr.Row():
+                    with gr.Column():
+                        budget_categories = gr.CheckboxGroup(
+                            choices=["Food & Dining", "Shopping", "Gas & Transport", 
+                                   "Utilities", "Entertainment", "Healthcare", "Other"],
+                            label="Categories to Budget",
+                            value=["Food & Dining", "Shopping", "Gas & Transport"]
+                        )
+                        
+                        budget_amounts = gr.JSON(
+                            label="Budget Amounts ($)",
+                            value={
+                                "Food & Dining": 500,
+                                "Shopping": 300,
+                                "Gas & Transport": 200,
+                                "Utilities": 150,
+                                "Entertainment": 100,
+                                "Healthcare": 200,
+                                "Other": 100
+                            }
+                        )
+                        
+                        save_budgets_btn = gr.Button("💾 Save Budget Settings", variant="primary")
+                    
+                    with gr.Column():
+                        budget_status = gr.HTML()
+                        current_budgets = gr.JSON(label="Current Budget Settings")
+            
+            with gr.TabItem("Email Settings"):
+                gr.Markdown("### Email Configuration")
+                
+                with gr.Row():
+                    with gr.Column():
+                        email_provider_setting = gr.Dropdown(
+                            choices=["Gmail", "Outlook", "Yahoo", "Custom"],
+                            label="Email Provider",
+                            value="Gmail"
+                        )
+                        
+                        imap_server = gr.Textbox(
+                            label="IMAP Server",
+                            value="imap.gmail.com",
+                            placeholder="imap.gmail.com"
+                        )
+                        
+                        imap_port = gr.Number(
+                            label="IMAP Port",
+                            value=993,
+                            precision=0
+                        )
+                        
+                        auto_process = gr.Checkbox(
+                            label="Auto-process new statements",
+                            value=False
+                        )
+                        
+                        save_email_btn = gr.Button("💾 Save Email Settings", variant="primary")
+                    
+                    with gr.Column():
+                        email_test_btn = gr.Button("🧪 Test Email Connection")
+                        email_test_status = gr.HTML()
+            
+            with gr.TabItem("Export Settings"):
+                gr.Markdown("### Data Export Options")
+                
+                export_format = gr.Radio(
+                    choices=["JSON", "CSV", "Excel"],
+                    label="Export Format",
+                    value="JSON"
+                )
+                
+                include_raw_data = gr.Checkbox(
+                    label="Include raw transaction data",
+                    value=True
+                )
+                
+                include_analysis = gr.Checkbox(
+                    label="Include analysis results",
+                    value=True
+                )
+                
+                export_settings_btn = gr.Button("📤 Export Current Analysis")
+        
+        # Event handlers
+        save_budgets_btn.click(
+            fn=self._save_budget_settings,
+            inputs=[budget_categories, budget_amounts],
+            outputs=[budget_status, current_budgets]
+        )
+        
+        save_email_btn.click(
+            fn=self._save_email_settings,
+            inputs=[email_provider_setting, imap_server, imap_port, auto_process],
+            outputs=[email_test_status]
+        )
+        
+        email_test_btn.click(
+            fn=self._test_email_connection,
+            inputs=[email_provider_setting, imap_server, imap_port],
+            outputs=[email_test_status]
+        )
+    
+    # Implementation methods
+    def _process_email_statements(self, provider, email, password, days_back):
+        """Process bank statements from email"""
+        try:
+            # Update status
+            status_html = '<div class="status-box warning-box">🔄 Processing email statements...</div>'
+            
+            # Configure email settings
+            email_config = {
+                'email': email,
+                'password': password,
+                'imap_server': self._get_imap_server(provider)
+            }
+            
+            # For now, simulate the Modal function call
+            # In production, this would call the actual Modal function
+            try:
+                # Simulate processing
+                import time
+                time.sleep(1)  # Simulate processing time
+                
+                # Mock result for demonstration
+                result = {
+                    'processed_statements': [
+                        {
+                            'filename': 'statement1.pdf',
+                            'bank': 'Chase',
+                            'account': '****1234',
+                            'transaction_count': 25,
+                            'status': 'success'
+                        }
+                    ],
+                    'total_transactions': 25,
+                    'analysis': {
+                        'financial_summary': {
+                            'total_income': 3000.0,
+                            'total_expenses': 1500.0,
+                            'net_cash_flow': 1500.0
+                        },
+                        'spending_insights': [
+                            {
+                                'category': 'Food & Dining',
+                                'total_amount': 400.0,
+                                'transaction_count': 12,
+                                'percentage_of_total': 26.7
+                            }
+                        ],
+                        'recommendations': ['Consider reducing dining out expenses'],
+                        'transaction_count': 25
+                    }
+                }
+                
+                status_html = f'<div class="status-box success-box">✅ Processed {result["total_transactions"]} transactions</div>'
+                password_inputs_visible = gr.update(visible=False)
+                
+                # Store analysis for dashboard
+                self.current_analysis = result.get('analysis', {})
+                
+                return status_html, result, password_inputs_visible
+                
+            except Exception as modal_error:
+                # Fallback to local processing if Modal is not available
+                self.logger.warning(f"Modal processing failed, using local fallback: {modal_error}")
+                return self._process_email_local(email_config, days_back)
+            
+        except Exception as e:
+            error_html = f'<div class="status-box error-box">❌ Error: {str(e)}</div>'
+            return error_html, {}, gr.update(visible=False)
+    
+    def _retry_with_passwords(self, provider, email, password, days_back, pdf_passwords):
+        """Retry processing with PDF passwords"""
+        try:
+            status_html = '<div class="status-box warning-box">🔄 Retrying with passwords...</div>'
+            
+            email_config = {
+                'email': email,
+                'password': password,
+                'imap_server': self._get_imap_server(provider)
+            }
+            
+            # Mock retry with passwords
+            result = {
+                'processed_statements': [
+                    {
+                        'filename': 'protected_statement.pdf',
+                        'bank': 'Bank of America',
+                        'account': '****5678',
+                        'transaction_count': 30,
+                        'status': 'success'
+                    }
+                ],
+                'total_transactions': 30,
+                'analysis': {
+                    'financial_summary': {
+                        'total_income': 3500.0,
+                        'total_expenses': 1800.0,
+                        'net_cash_flow': 1700.0
+                    },
+                    'spending_insights': [],
+                    'recommendations': [],
+                    'transaction_count': 30
+                }
+            }
+            
+            status_html = f'<div class="status-box success-box">✅ Processed {result["total_transactions"]} transactions</div>'
+            self.current_analysis = result.get('analysis', {})
+            
+            return status_html, result
+            
+        except Exception as e:
+            error_html = f'<div class="status-box error-box">❌ Error: {str(e)}</div>'
+            return error_html, {}
+    
+    def _analyze_pdf_files(self, files, passwords):
+        """Analyze uploaded PDF files"""
+        try:
+            if not files:
+                return '<div class="status-box error-box">❌ No files uploaded</div>', {}
+            
+            status_html = '<div class="status-box warning-box">🔄 Analyzing PDF files...</div>'
+            
+            # Mock PDF analysis
+            result = {
+                'processed_files': [],
+                'total_transactions': 0,
+                'analysis': {
+                    'financial_summary': {
+                        'total_income': 0,
+                        'total_expenses': 0,
+                        'net_cash_flow': 0
+                    },
+                    'spending_insights': [],
+                    'recommendations': [],
+                    'transaction_count': 0
+                }
+            }
+            
+            # Process each file
+            for file in files:
+                try:
+                    # Mock processing
+                    file_result = {
+                        'filename': file.name,
+                        'bank': 'Unknown Bank',
+                        'transaction_count': 15,
+                        'status': 'success'
+                    }
+                    result['processed_files'].append(file_result)
+                    result['total_transactions'] += 15
+                    
+                except Exception as file_error:
+                    result['processed_files'].append({
+                        'filename': file.name,
+                        'status': 'error',
+                        'error': str(file_error)
+                    })
+            
+            if result['total_transactions'] > 0:
+                status_html = f'<div class="status-box success-box">✅ Analyzed {result["total_transactions"]} transactions</div>'
+                self.current_analysis = result.get('analysis', {})
+            else:
+                status_html = '<div class="status-box warning-box">⚠️ No transactions found in uploaded files</div>'
+            
+            return status_html, result
+            
+        except Exception as e:
+            error_html = f'<div class="status-box error-box">❌ Error: {str(e)}</div>'
+            return error_html, {}
+    
+    def _process_email_local(self, email_config, days_back):
+        """Local fallback for email processing"""
+        # This would use the local email_processor module
+        status_html = '<div class="status-box warning-box">⚠️ Using local processing (Modal unavailable)</div>'
+        
+        # Mock local processing result
+        result = {
+            'processed_statements': [],
+            'total_transactions': 0,
+            'analysis': {
+                'financial_summary': {
+                    'total_income': 0,
+                    'total_expenses': 0,
+                    'net_cash_flow': 0
+                },
+                'spending_insights': [],
+                'recommendations': ['Please configure Modal deployment for full functionality'],
+                'transaction_count': 0
+            }
+        }
+        
+        return status_html, result, gr.update(visible=False)
+    
+    def _refresh_dashboard(self):
+        """Refresh dashboard with current analysis"""
+        if not self.current_analysis:
+            return (0, 0, 0, 0, None, None, 
+                   '<div class="status-box warning-box">⚠️ No analysis data available</div>',
+                   '<div class="status-box warning-box">⚠️ Process statements first</div>',
+                   pd.DataFrame())
+        
+        try:
+            summary = self.current_analysis.get('financial_summary', {})
+            insights = self.current_analysis.get('spending_insights', [])
+            
+            # Summary metrics
+            total_income = summary.get('total_income', 0)
+            total_expenses = summary.get('total_expenses', 0)
+            net_cashflow = summary.get('net_cash_flow', 0)
+            transaction_count = self.current_analysis.get('transaction_count', 0)
+            
+            # Create spending by category chart
+            if insights:
+                categories = [insight['category'] for insight in insights]
+                amounts = [insight['total_amount'] for insight in insights]
+                
+                spending_chart = px.pie(
+                    values=amounts,
+                    names=categories,
+                    title="Spending by Category"
+                )
+            else:
+                spending_chart = None
+            
+            # Create monthly trends chart
+            monthly_trends = summary.get('monthly_trends', {})
+            if monthly_trends:
+                trends_chart = px.line(
+                    x=list(monthly_trends.keys()),
+                    y=list(monthly_trends.values()),
+                    title="Monthly Spending Trends"
+                )
+            else:
+                trends_chart = None
+            
+            # Budget alerts
+            alerts = self.current_analysis.get('budget_alerts', [])
+            if alerts:
+                alert_html = '<div class="status-box warning-box"><h4>Budget Alerts:</h4><ul>'
+                for alert in alerts:
+                    alert_html += f'<li>{alert["category"]}: {alert["percentage_used"]:.1f}% used</li>'
+                alert_html += '</ul></div>'
+            else:
+                alert_html = '<div class="status-box success-box">✅ All budgets on track</div>'
+            
+            # Recommendations
+            recommendations = self.current_analysis.get('recommendations', [])
+            if recommendations:
+                rec_html = '<div class="status-box"><h4>Recommendations:</h4><ul>'
+                for rec in recommendations[:3]:  # Show top 3
+                    rec_html += f'<li>{rec}</li>'
+                rec_html += '</ul></div>'
+            else:
+                rec_html = '<div class="status-box">No specific recommendations at this time.</div>'
+            
+            # Transaction table (sample recent transactions)
+            transaction_df = pd.DataFrame()  # Would populate with actual transaction data
+            
+            return (total_income, total_expenses, net_cashflow, transaction_count,
+                   spending_chart, trends_chart, alert_html, rec_html, transaction_df)
+            
+        except Exception as e:
+            error_msg = f'<div class="status-box error-box">❌ Dashboard error: {str(e)}</div>'
+            return (0, 0, 0, 0, None, None, error_msg, error_msg, pd.DataFrame())
+    
+    def _export_analysis(self):
+        """Export current analysis data"""
+        if not self.current_analysis:
+            return None
+        
+        try:
+            import tempfile
+            import json
+            
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+                json.dump(self.current_analysis, f, indent=2, default=str)
+                return f.name
+                
+        except Exception as e:
+            self.logger.error(f"Export error: {e}")
+            return None
+    
+    def _handle_chat_message(self, message, chat_history):
+        """Handle chat messages with AI advisor"""
+        if not message.strip():
+            return chat_history, "", '<div class="status-box warning-box">⚠️ Please enter a message</div>'
+        
+        try:
+            # Add user message to chat
+            chat_history = chat_history or []
+            chat_history.append([message, None])
+            
+            status_html = '<div class="status-box warning-box">🤖 AI is thinking...</div>'
+            
+            # Mock AI response for now (would use Claude API in production)
+            if self.current_analysis:
+                # Generate a contextual response based on the analysis
+                summary = self.current_analysis.get('financial_summary', {})
+                insights = self.current_analysis.get('spending_insights', [])
+                recommendations = self.current_analysis.get('recommendations', [])
+                
+                if 'budget' in message.lower():
+                    ai_response = f"Based on your current spending analysis, you have a net cash flow of ${summary.get('net_cash_flow', 0):.2f}. Your total expenses are ${summary.get('total_expenses', 0):.2f} against an income of ${summary.get('total_income', 0):.2f}."
+                elif 'trend' in message.lower():
+                    if insights:
+                        top_category = insights[0]
+                        ai_response = f"Your top spending category is {top_category['category']} at ${top_category['total_amount']:.2f} ({top_category['percentage_of_total']:.1f}% of total spending). This represents {top_category['transaction_count']} transactions."
+                    else:
+                        ai_response = "I need more transaction data to analyze your spending trends effectively."
+                elif 'save' in message.lower() or 'tip' in message.lower():
+                    if recommendations:
+                        ai_response = f"Here are some personalized recommendations: {'. '.join(recommendations[:2])}"
+                    else:
+                        ai_response = "Based on your spending patterns, consider tracking your largest expense categories and setting monthly budgets for better financial control."
+                elif 'unusual' in message.lower() or 'activity' in message.lower():
+                    ai_response = "I've analyzed your transactions for unusual patterns. Currently, your spending appears consistent with normal patterns. I'll alert you if I detect any anomalies."
+                else:
+                    ai_response = f"I can see you have {self.current_analysis.get('transaction_count', 0)} transactions analyzed. Feel free to ask about your budget, spending trends, saving tips, or unusual activity. What specific aspect of your finances would you like to explore?"
+                
+                status_html = '<div class="status-box success-box">✅ Response generated</div>'
+            else:
+                ai_response = "I don't have any financial data to analyze yet. Please process your bank statements first using the Email Processing or PDF Upload tabs."
+                status_html = '<div class="status-box warning-box">⚠️ No data available</div>'
+            
+            # Update chat history with AI response
+            chat_history[-1][1] = ai_response
+            
+            return chat_history, "", status_html
+            
+        except Exception as e:
+            error_response = f"I'm sorry, I encountered an error: {str(e)}"
+            if chat_history:
+                chat_history[-1][1] = error_response
+            return chat_history, "", '<div class="status-box error-box">❌ Chat Error</div>'
+    
+    def _save_budget_settings(self, categories, amounts):
+        """Save budget settings"""
+        try:
+            # Filter amounts for selected categories
+            budget_settings = {cat: amounts.get(cat, 0) for cat in categories}
+            
+            # Store in user session (in real app, would save to database)
+            self.user_sessions['budgets'] = budget_settings
+            
+            status_html = '<div class="status-box success-box">✅ Budget settings saved</div>'
+            return status_html, budget_settings
+            
+        except Exception as e:
+            error_html = f'<div class="status-box error-box">❌ Error saving budgets: {str(e)}</div>'
+            return error_html, {}
+    
+    def _save_email_settings(self, provider, server, port, auto_process):
+        """Save email settings"""
+        try:
+            email_settings = {
+                'provider': provider,
+                'imap_server': server,
+                'imap_port': port,
+                'auto_process': auto_process
+            }
+            
+            self.user_sessions['email_settings'] = email_settings
+            
+            return '<div class="status-box success-box">✅ Email settings saved</div>'
+            
+        except Exception as e:
+            return f'<div class="status-box error-box">❌ Error saving settings: {str(e)}</div>'
+    
+    def _test_email_connection(self, provider, server, port):
+        """Test email connection"""
+        try:
+            # This would test the actual connection in a real implementation
+            return '<div class="status-box success-box">✅ Email connection test successful</div>'
+            
+        except Exception as e:
+            return f'<div class="status-box error-box">❌ Connection test failed: {str(e)}</div>'
+    
+    def _get_imap_server(self, provider):
+        """Get IMAP server for email provider"""
+        servers = {
+            'Gmail': 'imap.gmail.com',
+            'Outlook': 'outlook.office365.com',
+            'Yahoo': 'imap.mail.yahoo.com',
+            'Other': 'imap.gmail.com'  # Default
+        }
+        return servers.get(provider, 'imap.gmail.com')
+
+# Launch the interface
+def launch_interface():
+    """Launch the Gradio interface"""
+    interface = SpendAnalyzerInterface()
+    app = interface.create_interface()
+    
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    launch_interface()

gradio_interface_local.py

@@ -0,0 +1,627 @@
+"""
+Gradio Web Interface for Spend Analyzer MCP - Local Version
+"""
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import json
+import os
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime, timedelta
+import logging
+import time
+
+class SpendAnalyzerInterface:
+    def __init__(self):
+        self.current_analysis = None
+        self.user_sessions = {}
+        self.logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.INFO)
+        
+        # Load demo data if available
+        self.demo_data = self._load_demo_data()
+        
+    def _load_demo_data(self):
+        """Load demo data for testing"""
+        try:
+            if os.path.exists('demo_data.json'):
+                with open('demo_data.json', 'r') as f:
+                    return json.load(f)
+        except Exception as e:
+            self.logger.warning(f"Could not load demo data: {e}")
+        
+        # Fallback demo data
+        return {
+            "transactions": [
+                {
+                    "date": "2024-01-15",
+                    "description": "STARBUCKS COFFEE",
+                    "amount": -4.50,
+                    "category": "Food & Dining"
+                },
+                {
+                    "date": "2024-01-14", 
+                    "description": "AMAZON PURCHASE",
+                    "amount": -29.99,
+                    "category": "Shopping"
+                },
+                {
+                    "date": "2024-01-13",
+                    "description": "SALARY DEPOSIT",
+                    "amount": 3000.00,
+                    "category": "Income"
+                },
+                {
+                    "date": "2024-01-12",
+                    "description": "GROCERY STORE",
+                    "amount": -85.67,
+                    "category": "Food & Dining"
+                },
+                {
+                    "date": "2024-01-11",
+                    "description": "GAS STATION",
+                    "amount": -45.00,
+                    "category": "Gas & Transport"
+                }
+            ]
+        }
+        
+    def create_interface(self):
+        """Create the main Gradio interface"""
+        
+        with gr.Blocks(
+            title="Spend Analyzer MCP - Local Demo",
+            css="""
+            .main-header { text-align: center; margin: 20px 0; }
+            .status-box { padding: 10px; border-radius: 5px; margin: 10px 0; }
+            .success-box { background-color: #d4edda; border: 1px solid #c3e6cb; }
+            .error-box { background-color: #f8d7da; border: 1px solid #f5c6cb; }
+            .warning-box { background-color: #fff3cd; border: 1px solid #ffeaa7; }
+            .demo-box { background-color: #e7f3ff; border: 1px solid #b3d9ff; }
+            """
+        ) as interface:
+            
+            gr.Markdown("# 💰 Spend Analyzer MCP - Local Demo", elem_classes=["main-header"])
+            gr.Markdown("*Analyze your bank statements with AI-powered insights*")
+            
+            # Demo notice
+            gr.HTML('<div class="demo-box">🚀 <strong>Demo Mode:</strong> This is a local demonstration. Upload real PDFs or use the demo data to explore features.</div>')
+            
+            with gr.Tabs():
+                # Tab 1: Demo Data
+                with gr.TabItem("🎯 Demo Data"):
+                    self._create_demo_tab()
+                
+                # Tab 2: PDF Upload
+                with gr.TabItem("📄 PDF Upload"):
+                    self._create_pdf_tab()
+                
+                # Tab 3: Analysis Dashboard
+                with gr.TabItem("📊 Analysis Dashboard"):
+                    self._create_dashboard_tab()
+                
+                # Tab 4: AI Chat
+                with gr.TabItem("🤖 AI Financial Advisor"):
+                    self._create_chat_tab()
+                
+                # Tab 5: Settings
+                with gr.TabItem("⚙️ Settings"):
+                    self._create_settings_tab()
+        
+        return interface
+    
+    def _create_demo_tab(self):
+        """Create demo data tab"""
+        gr.Markdown("## 🎯 Demo Data & Quick Start")
+        gr.Markdown("*Load sample financial data to explore the features*")
+        
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Sample Transactions")
+                demo_transactions = gr.JSON(
+                    value=self.demo_data["transactions"],
+                    label="Demo Transaction Data"
+                )
+                
+                load_demo_btn = gr.Button("📊 Load Demo Data", variant="primary", size="lg")
+                
+            with gr.Column():
+                demo_status = gr.HTML()
+                
+                gr.Markdown("### Features to Try")
+                gr.Markdown("""
+                1. **Load Demo Data** - Click the button to analyze sample transactions
+                2. **View Dashboard** - See charts and financial summaries
+                3. **Chat with AI** - Ask questions about spending patterns
+                4. **Upload PDFs** - Try uploading your own bank statements
+                5. **Configure Settings** - Set budgets and preferences
+                """)
+        
+        # Event handler
+        load_demo_btn.click(
+            fn=self._load_demo_data_handler,
+            outputs=[demo_status]
+        )
+    
+    def _create_pdf_tab(self):
+        """Create PDF upload tab"""
+        gr.Markdown("## 📄 Upload Bank Statement PDFs")
+        gr.Markdown("*Upload your bank statement PDFs for analysis*")
+        
+        with gr.Row():
+            with gr.Column():
+                pdf_upload = gr.File(
+                    label="Upload Bank Statement PDFs",
+                    file_count="multiple",
+                    file_types=[".pdf"]
+                )
+                
+                analyze_pdf_btn = gr.Button("📊 Analyze PDFs", variant="primary")
+                
+            with gr.Column():
+                pdf_status = gr.HTML()
+                pdf_results = gr.JSON(label="Analysis Results", visible=False)
+        
+        # Event handler
+        analyze_pdf_btn.click(
+            fn=self._analyze_pdf_files,
+            inputs=[pdf_upload],
+            outputs=[pdf_status, pdf_results]
+        )
+    
+    def _create_dashboard_tab(self):
+        """Create analysis dashboard tab"""
+        gr.Markdown("## 📊 Financial Analysis Dashboard")
+        
+        with gr.Row():
+            refresh_btn = gr.Button("🔄 Refresh Dashboard")
+            export_btn = gr.Button("📤 Export Analysis")
+        
+        # Summary cards
+        with gr.Row():
+            total_income = gr.Number(label="Total Income ($)", interactive=False)
+            total_expenses = gr.Number(label="Total Expenses ($)", interactive=False)
+            net_cashflow = gr.Number(label="Net Cash Flow ($)", interactive=False)
+            transaction_count = gr.Number(label="Total Transactions", interactive=False)
+        
+        # Charts
+        with gr.Row():
+            with gr.Column():
+                spending_by_category = gr.Plot(label="Spending by Category")
+                monthly_trends = gr.Plot(label="Daily Spending Trends")
+            
+            with gr.Column():
+                budget_alerts = gr.HTML(label="Budget Alerts")
+                recommendations = gr.HTML(label="Recommendations")
+        
+        # Detailed data
+        with gr.Accordion("Detailed Transaction Data", open=False):
+            transaction_table = gr.Dataframe(
+                headers=["Date", "Description", "Amount", "Category"],
+                interactive=False,
+                label="Recent Transactions"
+            )
+        
+        # Event handlers
+        refresh_btn.click(
+            fn=self._refresh_dashboard,
+            outputs=[total_income, total_expenses, net_cashflow, transaction_count,
+                    spending_by_category, monthly_trends, budget_alerts, recommendations,
+                    transaction_table]
+        )
+        
+        export_btn.click(
+            fn=self._export_analysis,
+            outputs=[gr.File(label="Analysis Export")]
+        )
+    
+    def _create_chat_tab(self):
+        """Create AI chat tab"""
+        gr.Markdown("## 🤖 AI Financial Advisor")
+        gr.Markdown("*Ask questions about your spending patterns and get insights*")
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                chatbot = gr.Chatbot(
+                    label="Financial Advisor Chat",
+                    height=400,
+                    show_label=True,
+                    type="messages"
+                )
+                
+                with gr.Row():
+                    msg_input = gr.Textbox(
+                        placeholder="Ask about your spending patterns, budgets, or financial goals...",
+                        label="Your Question",
+                        scale=4
+                    )
+                    send_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                # Quick question buttons
+                with gr.Row():
+                    budget_btn = gr.Button("💰 Budget Analysis", size="sm")
+                    trends_btn = gr.Button("📈 Spending Trends", size="sm")
+                    tips_btn = gr.Button("💡 Save Money Tips", size="sm")
+                    unusual_btn = gr.Button("🚨 Unusual Activity", size="sm")
+            
+            with gr.Column(scale=1):
+                chat_status = gr.HTML()
+                
+                # Analysis context
+                gr.Markdown("### Current Analysis Context")
+                context_info = gr.JSON(
+                    label="Available Data",
+                    value={"status": "Load demo data or upload PDFs to start"}
+                )
+        
+        # Event handlers
+        send_btn.click(
+            fn=self._handle_chat_message,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input, chat_status]
+        )
+        
+        msg_input.submit(
+            fn=self._handle_chat_message,
+            inputs=[msg_input, chatbot],
+            outputs=[chatbot, msg_input, chat_status]
+        )
+        
+        # Quick question handlers
+        budget_btn.click(
+            lambda: "How am I doing with my budget this month?",
+            outputs=[msg_input]
+        )
+        trends_btn.click(
+            lambda: "What are my spending trends over the last few days?",
+            outputs=[msg_input]
+        )
+        tips_btn.click(
+            lambda: "What are some specific ways I can save money based on my spending?",
+            outputs=[msg_input]
+        )
+        unusual_btn.click(
+            lambda: "Are there any unusual transactions I should be aware of?",
+            outputs=[msg_input]
+        )
+    
+    def _create_settings_tab(self):
+        """Create settings tab"""
+        gr.Markdown("## ⚙️ Settings & Configuration")
+        
+        with gr.Tabs():
+            with gr.TabItem("Budget Settings"):
+                gr.Markdown("### Set Monthly Budget Limits")
+                
+                with gr.Row():
+                    with gr.Column():
+                        budget_categories = gr.CheckboxGroup(
+                            choices=["Food & Dining", "Shopping", "Gas & Transport", 
+                                   "Utilities", "Entertainment", "Healthcare", "Other"],
+                            label="Categories to Budget",
+                            value=["Food & Dining", "Shopping", "Gas & Transport"]
+                        )
+                        
+                        budget_amounts = gr.JSON(
+                            label="Budget Amounts ($)",
+                            value={
+                                "Food & Dining": 500,
+                                "Shopping": 300,
+                                "Gas & Transport": 200,
+                                "Utilities": 150,
+                                "Entertainment": 100,
+                                "Healthcare": 200,
+                                "Other": 100
+                            }
+                        )
+                        
+                        save_budgets_btn = gr.Button("💾 Save Budget Settings", variant="primary")
+                    
+                    with gr.Column():
+                        budget_status = gr.HTML()
+                        current_budgets = gr.JSON(label="Current Budget Settings")
+            
+            with gr.TabItem("Export Settings"):
+                gr.Markdown("### Data Export Options")
+                
+                export_format = gr.Radio(
+                    choices=["JSON", "CSV"],
+                    label="Export Format",
+                    value="JSON"
+                )
+                
+                include_raw_data = gr.Checkbox(
+                    label="Include raw transaction data",
+                    value=True
+                )
+                
+                include_analysis = gr.Checkbox(
+                    label="Include analysis results",
+                    value=True
+                )
+        
+        # Event handlers
+        save_budgets_btn.click(
+            fn=self._save_budget_settings,
+            inputs=[budget_categories, budget_amounts],
+            outputs=[budget_status, current_budgets]
+        )
+    
+    # Implementation methods
+    def _load_demo_data_handler(self):
+        """Load demo data and create analysis"""
+        try:
+            # Simulate processing
+            time.sleep(1)
+            
+            # Create mock analysis from demo data
+            transactions = self.demo_data["transactions"]
+            
+            total_income = sum(t["amount"] for t in transactions if t["amount"] > 0)
+            total_expenses = abs(sum(t["amount"] for t in transactions if t["amount"] < 0))
+            
+            # Group by category
+            categories = {}
+            for t in transactions:
+                if t["amount"] < 0:  # Only expenses
+                    cat = t["category"]
+                    if cat not in categories:
+                        categories[cat] = {"total": 0, "count": 0}
+                    categories[cat]["total"] += abs(t["amount"])
+                    categories[cat]["count"] += 1
+            
+            spending_insights = []
+            for cat, data in categories.items():
+                spending_insights.append({
+                    "category": cat,
+                    "total_amount": data["total"],
+                    "transaction_count": data["count"],
+                    "percentage_of_total": (data["total"] / total_expenses) * 100 if total_expenses > 0 else 0
+                })
+            
+            self.current_analysis = {
+                "financial_summary": {
+                    "total_income": total_income,
+                    "total_expenses": total_expenses,
+                    "net_cash_flow": total_income - total_expenses
+                },
+                "spending_insights": spending_insights,
+                "recommendations": [
+                    "Your Food & Dining expenses are significant. Consider cooking more meals at home.",
+                    "Great job maintaining a positive cash flow!",
+                    "Track your daily expenses to identify more saving opportunities."
+                ],
+                "transaction_count": len(transactions)
+            }
+            
+            return '<div class="status-box success-box">✅ Demo data loaded successfully! Check the Dashboard tab to see your analysis.</div>'
+            
+        except Exception as e:
+            return f'<div class="status-box error-box">❌ Error loading demo data: {str(e)}</div>'
+    
+    def _analyze_pdf_files(self, files):
+        """Analyze uploaded PDF files (mock implementation)"""
+        try:
+            if not files:
+                return '<div class="status-box error-box">❌ No files uploaded</div>', {}
+            
+            # Mock PDF analysis
+            result = {
+                'processed_files': [],
+                'total_transactions': 0
+            }
+            
+            for file in files:
+                # Mock processing
+                file_result = {
+                    'filename': file.name,
+                    'status': 'success',
+                    'message': 'PDF parsing not implemented in demo mode'
+                }
+                result['processed_files'].append(file_result)
+            
+            status_html = f'<div class="status-box warning-box">⚠️ PDF processing is not implemented in demo mode. Use the Demo Data tab instead.</div>'
+            
+            return status_html, result
+            
+        except Exception as e:
+            error_html = f'<div class="status-box error-box">❌ Error: {str(e)}</div>'
+            return error_html, {}
+    
+    def _refresh_dashboard(self):
+        """Refresh dashboard with current analysis"""
+        if not self.current_analysis:
+            return (0, 0, 0, 0, None, None, 
+                   '<div class="status-box warning-box">⚠️ No analysis data available. Load demo data first!</div>',
+                   '<div class="status-box warning-box">⚠️ Load demo data to see recommendations</div>',
+                   pd.DataFrame())
+        
+        try:
+            summary = self.current_analysis.get('financial_summary', {})
+            insights = self.current_analysis.get('spending_insights', [])
+            
+            # Summary metrics
+            total_income = summary.get('total_income', 0)
+            total_expenses = summary.get('total_expenses', 0)
+            net_cashflow = summary.get('net_cash_flow', 0)
+            transaction_count = self.current_analysis.get('transaction_count', 0)
+            
+            # Create spending by category chart
+            if insights:
+                categories = [insight['category'] for insight in insights]
+                amounts = [insight['total_amount'] for insight in insights]
+                
+                spending_chart = px.pie(
+                    values=amounts,
+                    names=categories,
+                    title="Spending by Category"
+                )
+                spending_chart.update_layout(height=400)
+            else:
+                spending_chart = None
+            
+            # Create daily trends chart
+            transactions = self.demo_data.get("transactions", [])
+            if transactions:
+                # Group by date
+                daily_spending = {}
+                for t in transactions:
+                    if t["amount"] < 0:  # Only expenses
+                        date = t["date"]
+                        if date not in daily_spending:
+                            daily_spending[date] = 0
+                        daily_spending[date] += abs(t["amount"])
+                
+                dates = list(daily_spending.keys())
+                amounts = list(daily_spending.values())
+                
+                trends_chart = px.line(
+                    x=dates,
+                    y=amounts,
+                    title="Daily Spending Trends",
+                    labels={"x": "Date", "y": "Amount ($)"}
+                )
+                trends_chart.update_layout(height=400)
+            else:
+                trends_chart = None
+            
+            # Budget alerts
+            alert_html = '<div class="status-box success-box">✅ All spending within reasonable limits</div>'
+            
+            # Recommendations
+            recommendations = self.current_analysis.get('recommendations', [])
+            if recommendations:
+                rec_html = '<div class="status-box"><h4>💡 Recommendations:</h4><ul>'
+                for rec in recommendations:
+                    rec_html += f'<li>{rec}</li>'
+                rec_html += '</ul></div>'
+            else:
+                rec_html = '<div class="status-box">No specific recommendations at this time.</div>'
+            
+            # Transaction table
+            transaction_data = []
+            for t in transactions:
+                transaction_data.append([
+                    t["date"],
+                    t["description"],
+                    f"${t['amount']:.2f}",
+                    t["category"]
+                ])
+            
+            transaction_df = pd.DataFrame(
+                transaction_data,
+                columns=["Date", "Description", "Amount", "Category"]
+            )
+            
+            return (total_income, total_expenses, net_cashflow, transaction_count,
+                   spending_chart, trends_chart, alert_html, rec_html, transaction_df)
+            
+        except Exception as e:
+            error_msg = f'<div class="status-box error-box">❌ Dashboard error: {str(e)}</div>'
+            return (0, 0, 0, 0, None, None, error_msg, error_msg, pd.DataFrame())
+    
+    def _export_analysis(self):
+        """Export current analysis data"""
+        if not self.current_analysis:
+            return None
+        
+        try:
+            import tempfile
+            
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+                json.dump(self.current_analysis, f, indent=2, default=str)
+                return f.name
+                
+        except Exception as e:
+            self.logger.error(f"Export error: {e}")
+            return None
+    
+    def _handle_chat_message(self, message, chat_history):
+        """Handle chat messages with AI advisor"""
+        if not message.strip():
+            return chat_history, "", '<div class="status-box warning-box">⚠️ Please enter a message</div>'
+        
+        try:
+            # Add user message to chat
+            chat_history = chat_history or []
+            chat_history.append([message, None])
+            
+            # Generate response based on analysis
+            if self.current_analysis:
+                summary = self.current_analysis.get('financial_summary', {})
+                insights = self.current_analysis.get('spending_insights', [])
+                recommendations = self.current_analysis.get('recommendations', [])
+                
+                if 'budget' in message.lower():
+                    ai_response = f"Based on your analysis, you have a net cash flow of ${summary.get('net_cash_flow', 0):.2f}. Your total expenses are ${summary.get('total_expenses', 0):.2f} against an income of ${summary.get('total_income', 0):.2f}."
+                elif 'trend' in message.lower():
+                    if insights:
+                        top_category = insights[0]
+                        ai_response = f"Your top spending category is {top_category['category']} at ${top_category['total_amount']:.2f} ({top_category['percentage_of_total']:.1f}% of total spending)."
+                    else:
+                        ai_response = "I need more transaction data to analyze your spending trends effectively."
+                elif 'save' in message.lower() or 'tip' in message.lower():
+                    if recommendations:
+                        ai_response = f"Here are some personalized recommendations: {'. '.join(recommendations[:2])}"
+                    else:
+                        ai_response = "Based on your spending patterns, consider tracking your largest expense categories and setting monthly budgets."
+                elif 'unusual' in message.lower() or 'activity' in message.lower():
+                    ai_response = "I've analyzed your transactions and they appear normal. All transactions seem consistent with typical spending patterns."
+                else:
+                    ai_response = f"I can see you have {self.current_analysis.get('transaction_count', 0)} transactions analyzed. Feel free to ask about your budget, spending trends, saving tips, or unusual activity!"
+                
+                status_html = '<div class="status-box success-box">✅ Response generated</div>'
+            else:
+                ai_response = "I don't have any financial data to analyze yet. Please load the demo data or upload PDFs first!"
+                status_html = '<div class="status-box warning-box">⚠️ No data available</div>'
+            
+            # Update chat history with AI response
+            chat_history[-1][1] = ai_response
+            
+            return chat_history, "", status_html
+            
+        except Exception as e:
+            error_response = f"I'm sorry, I encountered an error: {str(e)}"
+            if chat_history:
+                chat_history[-1][1] = error_response
+            return chat_history, "", '<div class="status-box error-box">❌ Chat Error</div>'
+    
+    def _save_budget_settings(self, categories, amounts):
+        """Save budget settings"""
+        try:
+            # Filter amounts for selected categories
+            budget_settings = {cat: amounts.get(cat, 0) for cat in categories}
+            
+            # Store in user session
+            self.user_sessions['budgets'] = budget_settings
+            
+            status_html = '<div class="status-box success-box">✅ Budget settings saved</div>'
+            return status_html, budget_settings
+            
+        except Exception as e:
+            error_html = f'<div class="status-box error-box">❌ Error saving budgets: {str(e)}</div>'
+            return error_html, {}
+
+# Launch the interface
+def launch_interface():
+    """Launch the Gradio interface"""
+    interface = SpendAnalyzerInterface()
+    app = interface.create_interface()
+    
+    print("🚀 Starting Spend Analyzer MCP - Local Demo")
+    print("📊 Demo mode: Use the Demo Data tab to get started")
+    print("🌐 Opening in browser...")
+    
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7861,
+        share=False,
+        debug=True,
+        show_error=True,
+        inbrowser=True
+    )
+
+if __name__ == "__main__":
+    launch_interface()

gradio_interface_real.py

@@ -0,0 +1,845 @@
+"""
+Gradio Web Interface for Spend Analyzer MCP - Real PDF Processing
+"""
+import gradio as gr
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+import json
+import os
+import asyncio
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime, timedelta
+import logging
+import time
+import tempfile
+
+# Import our local modules
+from email_processor import PDFProcessor
+from spend_analyzer import SpendAnalyzer
+
+class RealSpendAnalyzerInterface:
+    def __init__(self):
+        self.current_analysis = None
+        self.user_sessions = {}
+        self.logger = logging.getLogger(__name__)
+        logging.basicConfig(level=logging.INFO)
+
+        # Initialize processors
+        self.pdf_processor = PDFProcessor()
+        self.spend_analyzer = SpendAnalyzer()
+
+    def create_interface(self):
+        """Create the main Gradio interface"""
+        with gr.Blocks(
+            title="Spend Analyzer MCP - Real PDF Processing",
+            css="""
+            .main-header { text-align: center; margin: 20px 0; }
+            .status-box { padding: 10px; border-radius: 5px; margin: 10px 0; }
+            .success-box { background-color: #d4edda; border: 1px solid #c3e6cb; }
+            .error-box { background-color: #f8d7da; border: 1px solid #f5c6cb; }
+            .warning-box { background-color: #fff3cd; border: 1px solid #ffeaa7; }
+            .info-box { background-color: #e7f3ff; border: 1px solid #b3d9ff; }
+            """
+        ) as interface:
+            gr.Markdown("# 💰 Spend Analyzer MCP - Real PDF Processing", elem_classes=["main-header"])
+            gr.Markdown("*Analyze your real bank statement PDFs with AI-powered insights*")
+
+            # Info notice
+            gr.HTML('<div class="info-box">📄 <strong>Real PDF Processing:</strong> Upload your actual bank statement PDFs for comprehensive financial analysis.</div>')
+
+            with gr.Tabs():
+                # Tab 1: PDF Upload & Processing
+                with gr.TabItem("📄 PDF Upload & Analysis"):
+                    self._create_pdf_processing_tab()
+
+                # Tab 2: Analysis Dashboard
+                with gr.TabItem("📊 Analysis Dashboard"):
+                    self._create_dashboard_tab()
+
+                # Tab 3: AI Financial Advisor
+                with gr.TabItem("🤖 AI Financial Advisor"):
+                    self._create_chat_tab()
+
+                # Tab 4: Transaction Management
+                with gr.TabItem("📋 Transaction Management"):
+                    self._create_transaction_tab()
+
+                # Tab 5: Settings & Export
+                with gr.TabItem("⚙️ Settings & Export"):
+                    self._create_settings_tab()
+
+        return interface
+
+    def _create_pdf_processing_tab(self):
+        """Create PDF processing tab"""
+        gr.Markdown("## 📄 Upload & Process Bank Statement PDFs")
+        gr.Markdown("*Upload your bank statement PDFs for real financial analysis*")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                # File upload section
+                gr.Markdown("### 📁 File Upload")
+                pdf_upload = gr.File(
+                    label="Upload Bank Statement PDFs",
+                    file_count="multiple",
+                    file_types=[".pdf"],
+                    height=150
+                )
+
+                # Password section
+                gr.Markdown("### 🔐 PDF Passwords (if needed)")
+                pdf_passwords_input = gr.Textbox(
+                    label="PDF Passwords (JSON format)",
+                    placeholder='{"statement1.pdf": "password123", "statement2.pdf": "password456"}',
+                    lines=3
+                )
+
+                # Processing options
+                gr.Markdown("### ⚙️ Processing Options")
+                with gr.Row():
+                    auto_categorize = gr.Checkbox(
+                        label="Auto-categorize transactions",
+                        value=True
+                    )
+                    detect_duplicates = gr.Checkbox(
+                        label="Detect duplicate transactions",
+                        value=True
+                    )
+
+                # Process button
+                process_pdf_btn = gr.Button("🚀 Process PDFs", variant="primary", size="lg")
+
+            with gr.Column(scale=1):
+                # Status and results
+                processing_status = gr.HTML()
+
+                # Processing progress
+                gr.Markdown("### 📊 Processing Results")
+                processing_results = gr.JSON(
+                    label="Detailed Results",
+                    visible=False
+                )
+
+                # Quick stats
+                quick_stats = gr.HTML()
+
+        # Event handler
+        process_pdf_btn.click(
+            fn=self._process_real_pdfs,
+            inputs=[pdf_upload, pdf_passwords_input, auto_categorize, detect_duplicates],
+            outputs=[processing_status, processing_results, quick_stats]
+        )
+
+    def _create_dashboard_tab(self):
+        """Create analysis dashboard tab"""
+        gr.Markdown("## 📊 Financial Analysis Dashboard")
+
+        with gr.Row():
+            refresh_btn = gr.Button("🔄 Refresh Dashboard")
+            export_btn = gr.Button("📤 Export Analysis")
+            clear_btn = gr.Button("🗑️ Clear Data", variant="stop")
+
+        # Summary cards
+        gr.Markdown("### 💰 Financial Summary")
+        with gr.Row():
+            total_income = gr.Number(label="Total Income ($)", interactive=False)
+            total_expenses = gr.Number(label="Total Expenses ($)", interactive=False)
+            net_cashflow = gr.Number(label="Net Cash Flow ($)", interactive=False)
+            transaction_count = gr.Number(label="Total Transactions", interactive=False)
+
+        # Charts section
+        gr.Markdown("### 📈 Visual Analysis")
+        with gr.Row():
+            with gr.Column():
+                spending_by_category = gr.Plot(label="Spending by Category")
+                monthly_trends = gr.Plot(label="Monthly Spending Trends")
+
+            with gr.Column():
+                income_vs_expenses = gr.Plot(label="Income vs Expenses")
+                top_merchants = gr.Plot(label="Top Merchants")
+
+        # Insights section
+        gr.Markdown("### 🎯 Financial Insights")
+        with gr.Row():
+            with gr.Column():
+                budget_alerts = gr.HTML(label="Budget Alerts")
+                spending_insights = gr.HTML(label="Spending Insights")
+
+            with gr.Column():
+                recommendations = gr.HTML(label="AI Recommendations")
+                unusual_transactions = gr.HTML(label="Unusual Transactions")
+
+        # Detailed data
+        with gr.Accordion("📋 Detailed Transaction Data", open=False):
+            transaction_table = gr.Dataframe(
+                headers=["Date", "Description", "Amount", "Category", "Account"],
+                interactive=True,
+                label="All Transactions"
+            )
+
+        # Status displays for clear function
+        clear_status = gr.HTML()
+        clear_info = gr.HTML()
+
+        # Event handlers
+        refresh_btn.click(
+            fn=self._refresh_dashboard,
+            outputs=[total_income, total_expenses, net_cashflow, transaction_count,
+                    spending_by_category, monthly_trends, income_vs_expenses, top_merchants,
+                    budget_alerts, spending_insights, recommendations, unusual_transactions,
+                    transaction_table]
+        )
+
+        export_btn.click(
+            fn=self._export_analysis,
+            outputs=[gr.File(label="Analysis Export")]
+        )
+
+        clear_btn.click(
+            fn=self._clear_data,
+            outputs=[clear_status, clear_info]
+        )
+
+    def _create_chat_tab(self):
+        """Create AI chat tab"""
+        gr.Markdown("## 🤖 AI Financial Advisor")
+        gr.Markdown("*Get personalized insights about your spending patterns*")
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                # Chat interface
+                chatbot = gr.Chatbot(
+                    label="Financial Advisor Chat",
+                    height=500,
+                    show_label=True
+                )
+
+                with gr.Row():
+                    msg_input = gr.Textbox(
+                        placeholder="Ask about your spending patterns, budgets, or financial goals...",
+                        label="Your Question",
+                        scale=4
+                    )
+                    send_btn = gr.Button("Send", variant="primary", scale=1)
+
+                # Quick question buttons
+                gr.Markdown("### 🎯 Quick Questions")
+                with gr.Row():
+                    budget_btn = gr.Button("💰 Budget Analysis", size="sm")
+                    trends_btn = gr.Button("📈 Spending Trends", size="sm")
+                    tips_btn = gr.Button("💡 Save Money Tips", size="sm")
+                    unusual_btn = gr.Button("🚨 Unusual Activity", size="sm")
+
+                with gr.Row():
+                    categories_btn = gr.Button("📊 Category Breakdown", size="sm")
+                    merchants_btn = gr.Button("🏪 Top Merchants", size="sm")
+                    monthly_btn = gr.Button("📅 Monthly Analysis", size="sm")
+                    goals_btn = gr.Button("🎯 Financial Goals", size="sm")
+
+            with gr.Column(scale=1):
+                chat_status = gr.HTML()
+
+                # Analysis context
+                gr.Markdown("### 📊 Analysis Context")
+                context_info = gr.JSON(
+                    label="Available Data",
+                    value={"status": "Upload PDFs to start analysis"}
+                )
+
+                # Chat settings
+                gr.Markdown("### ⚙️ Chat Settings")
+                response_style = gr.Radio(
+                    choices=["Detailed", "Concise", "Technical"],
+                    label="Response Style",
+                    value="Detailed"
+                )
+
+        # Event handlers
+        send_btn.click(
+            fn=self._handle_chat_message,
+            inputs=[msg_input, chatbot, response_style],
+            outputs=[chatbot, msg_input, chat_status]
+        )
+
+        msg_input.submit(
+            fn=self._handle_chat_message,
+            inputs=[msg_input, chatbot, response_style],
+            outputs=[chatbot, msg_input, chat_status]
+        )
+
+        # Quick question handlers
+        budget_btn.click(lambda: "How am I doing with my budget this month?", outputs=[msg_input])
+        trends_btn.click(lambda: "What are my spending trends over the last few months?", outputs=[msg_input])
+        tips_btn.click(lambda: "What are specific ways I can save money based on my spending?", outputs=[msg_input])
+        unusual_btn.click(lambda: "Are there any unusual transactions I should be aware of?", outputs=[msg_input])
+        categories_btn.click(lambda: "Break down my spending by category", outputs=[msg_input])
+        merchants_btn.click(lambda: "Who are my top merchants and how much do I spend with them?", outputs=[msg_input])
+        monthly_btn.click(lambda: "Analyze my monthly spending patterns", outputs=[msg_input])
+        goals_btn.click(lambda: "Help me set realistic financial goals based on my spending", outputs=[msg_input])
+
+    def _create_transaction_tab(self):
+        """Create transaction management tab"""
+        gr.Markdown("## 📋 Transaction Management")
+        gr.Markdown("*Review, edit, and categorize your transactions*")
+
+        with gr.Row():
+            with gr.Column(scale=2):
+                # Transaction filters
+                gr.Markdown("### 🔍 Filter Transactions")
+                with gr.Row():
+                    date_from = gr.Textbox(label="From Date (YYYY-MM-DD)", placeholder="2024-01-01")
+                    date_to = gr.Textbox(label="To Date (YYYY-MM-DD)", placeholder="2024-12-31")
+
+                with gr.Row():
+                    category_filter = gr.Dropdown(
+                        choices=["All", "Food & Dining", "Shopping", "Gas & Transport", 
+                               "Utilities", "Entertainment", "Healthcare", "Other"],
+                        label="Category Filter",
+                        value="All"
+                    )
+                    amount_filter = gr.Radio(
+                        choices=["All", "Income Only", "Expenses Only", "> $100", "> $500"],
+                        label="Amount Filter",
+                        value="All"
+                    )
+
+                filter_btn = gr.Button("🔍 Apply Filters", variant="secondary")
+
+                # Transaction editing
+                gr.Markdown("### ✏️ Edit Transaction")
+                with gr.Row():
+                    edit_transaction_id = gr.Number(label="Transaction ID", precision=0)
+                    edit_category = gr.Dropdown(
+                        choices=["Food & Dining", "Shopping", "Gas & Transport", 
+                               "Utilities", "Entertainment", "Healthcare", "Other"],
+                        label="New Category"
+                    )
+
+                update_btn = gr.Button("💾 Update Transaction", variant="primary")
+
+            with gr.Column(scale=1):
+                # Transaction stats
+                gr.Markdown("### 📊 Transaction Statistics")
+                transaction_stats = gr.HTML()
+
+                # Category management
+                gr.Markdown("### 🏷️ Category Management")
+                add_category = gr.Textbox(label="Add New Category")
+                add_category_btn = gr.Button("➕ Add Category")
+
+                category_status = gr.HTML()
+
+        # Filtered transactions table
+        filtered_transactions = gr.Dataframe(
+            headers=["ID", "Date", "Description", "Amount", "Category", "Account"],
+            interactive=False,
+            label="Filtered Transactions"
+        )
+
+        # Event handlers
+        filter_btn.click(
+            fn=self._filter_transactions,
+            inputs=[date_from, date_to, category_filter, amount_filter],
+            outputs=[filtered_transactions, transaction_stats]
+        )
+
+        update_btn.click(
+            fn=self._update_transaction,
+            inputs=[edit_transaction_id, edit_category],
+            outputs=[category_status, filtered_transactions]
+        )
+
+        add_category_btn.click(
+            fn=self._add_category,
+            inputs=[add_category],
+            outputs=[category_status, edit_category, category_filter]
+        )
+
+    def _create_settings_tab(self):
+        """Create settings and export tab"""
+        gr.Markdown("## ⚙️ Settings & Export")
+
+        with gr.Tabs():
+            with gr.TabItem("Budget Settings"):
+                gr.Markdown("### 💰 Monthly Budget Configuration")
+
+                with gr.Row():
+                    with gr.Column():
+                        budget_categories = gr.CheckboxGroup(
+                            choices=["Food & Dining", "Shopping", "Gas & Transport", 
+                                   "Utilities", "Entertainment", "Healthcare", "Other"],
+                            label="Categories to Budget",
+                            value=["Food & Dining", "Shopping", "Gas & Transport"]
+                        )
+
+                        budget_amounts = gr.JSON(
+                            label="Budget Amounts ($)",
+                            value={
+                                "Food & Dining": 500,
+                                "Shopping": 300,
+                                "Gas & Transport": 200,
+                                "Utilities": 150,
+                                "Entertainment": 100,
+                                "Healthcare": 200,
+                                "Other": 100
+                            }
+                        )
+
+                        save_budgets_btn = gr.Button("💾 Save Budget Settings", variant="primary")
+
+                    with gr.Column():
+                        budget_status = gr.HTML()
+                        current_budgets = gr.JSON(label="Current Budget Settings")
+
+            with gr.TabItem("Export Options"):
+                gr.Markdown("### 📤 Data Export")
+
+                with gr.Row():
+                    with gr.Column():
+                        export_format = gr.Radio(
+                            choices=["JSON", "CSV", "Excel"],
+                            label="Export Format",
+                            value="CSV"
+                        )
+
+                        export_options = gr.CheckboxGroup(
+                            choices=["Raw Transactions", "Analysis Summary", "Charts Data", "Recommendations"],
+                            label="Include in Export",
+                            value=["Raw Transactions", "Analysis Summary"]
+                        )
+
+                        date_range_export = gr.CheckboxGroup(
+                            choices=["Last 30 days", "Last 90 days", "Last 6 months", "All data"],
+                            label="Date Range",
+                            value=["All data"]
+                        )
+
+                        export_data_btn = gr.Button("📤 Export Data", variant="primary")
+
+                    with gr.Column():
+                        export_status = gr.HTML()
+
+                        gr.Markdown("### 📊 Export Preview")
+                        export_preview = gr.JSON(label="Export Preview")
+
+            with gr.TabItem("Processing Settings"):
+                gr.Markdown("### ⚙️ PDF Processing Configuration")
+
+                processing_settings = gr.JSON(
+                    label="Processing Settings",
+                    value={
+                        "auto_categorize": True,
+                        "detect_duplicates": True,
+                        "merge_similar_transactions": False,
+                        "confidence_threshold": 0.8,
+                        "date_format": "auto",
+                        "amount_format": "auto"
+                    }
+                )
+
+                save_processing_btn = gr.Button("💾 Save Processing Settings", variant="primary")
+                processing_status = gr.HTML()
+
+        # Event handlers
+        save_budgets_btn.click(
+            fn=self._save_budget_settings,
+            inputs=[budget_categories, budget_amounts],
+            outputs=[budget_status, current_budgets]
+        )
+
+        export_data_btn.click(
+            fn=self._export_data,
+            inputs=[export_format, export_options, date_range_export],
+            outputs=[export_status, export_preview, gr.File(label="Export File")]
+        )
+
+        save_processing_btn.click(
+            fn=self._save_processing_settings,
+            inputs=[processing_settings],
+            outputs=[processing_status]
+        )
+
+    # Implementation methods
+    def _process_real_pdfs(self, files, passwords_json, auto_categorize, detect_duplicates):
+        """Process real PDF files"""
+        try:
+            if not files:
+                return ('<div class="status-box error-box"> No files uploaded</div>', 
+                       gr.update(visible=False), "")
+
+            # Update status
+            status_html = '<div class="status-box warning-box"> Processing PDF files...</div>'
+
+            # Parse passwords if provided
+            passwords = {}
+            if isinstance(passwords_json, dict):
+                passwords = passwords_json
+            elif passwords_json.strip():
+                try:
+                    passwords = json.loads(passwords_json)
+                except json.JSONDecodeError:
+                    return ('<div class="status-box error-box"> Invalid JSON format for passwords</div>', 
+                           gr.update(visible=False), "")
+
+            all_transactions = []
+            processed_files = []
+
+            # Process each PDF
+            for file in files:
+                try:
+                    # Read file content
+                    with open(file.name, 'rb') as f:
+                        pdf_content = f.read()
+
+                    # Get password for this file
+                    file_password = passwords.get(os.path.basename(file.name))
+
+                    # Process PDF
+                    statement_info = asyncio.run(
+                        self.pdf_processor.process_pdf(pdf_content, file_password)
+                    )
+
+                    # Add transactions
+                    all_transactions.extend(statement_info.transactions)
+
+                    processed_files.append({
+                        'filename': os.path.basename(file.name),
+                        'bank': statement_info.bank_name,
+                        'account': statement_info.account_number,
+                        'period': statement_info.statement_period,
+                        'transaction_count': len(statement_info.transactions),
+                        'opening_balance': statement_info.opening_balance,
+                        'closing_balance': statement_info.closing_balance,
+                        'status': 'success'
+                    })
+
+                except Exception as e:
+                    processed_files.append({
+                        'filename': os.path.basename(file.name),
+                        'status': 'error',
+                        'error': str(e)
+                    })
+
+            if not all_transactions:
+                return ('<div class="status-box warning-box"> No transactions found in uploaded files</div>',
+                       gr.update(value={"processed_files": processed_files}, visible=True), "")
+
+            # Load transactions into analyzer
+            self.spend_analyzer.load_transactions(all_transactions)
+
+            # Generate analysis
+            self.current_analysis = self.spend_analyzer.export_analysis_data()
+
+            # Create success status
+            status_html = f'<div class="status-box success-box"> Successfully processed {len(processed_files)} files with {len(all_transactions)} transactions</div>'
+
+            # Create quick stats
+            total_income = sum(t.amount for t in all_transactions if t.amount > 0)
+            total_expenses = abs(sum(t.amount for t in all_transactions if t.amount < 0))
+
+            quick_stats_html = f'''
+            <div class="status-box info-box">
+                <h4> Quick Statistics</h4>
+                <ul>
+                    <li><strong>Total Income:</strong> ${total_income:,.2f}</li>
+                    <li><strong>Total Expenses:</strong> ${total_expenses:,.2f}</li>
+                    <li><strong>Net Cash Flow:</strong> ${total_income - total_expenses:,.2f}</li>
+                    <li><strong>Transaction Count:</strong> {len(all_transactions)}</li>
+                </ul>
+            </div>
+            '''
+
+            results = {
+                "processed_files": processed_files,
+                "total_transactions": len(all_transactions),
+                "analysis_summary": {
+                    "total_income": total_income,
+                    "total_expenses": total_expenses,
+                    "net_cash_flow": total_income - total_expenses
+                }
+            }
+
+            return (status_html, 
+                   gr.update(value=results, visible=True), 
+                   quick_stats_html)
+
+        except Exception as e:
+            error_html = f'<div class="status-box error-box"> Processing error: {str(e)}</div>'
+            return error_html, gr.update(visible=False), ""
+
+    def _refresh_dashboard(self):
+        """Refresh dashboard with current analysis"""
+        if not self.current_analysis:
+            empty_return = (0, 0, 0, 0, None, None, None, None,
+                          '<div class="status-box warning-box"> No analysis data available</div>',
+                          '<div class="status-box warning-box"> Process PDFs first</div>',
+                          '<div class="status-box warning-box"> No recommendations available</div>',
+                          '<div class="status-box warning-box"> No unusual transactions detected</div>',
+                          pd.DataFrame())
+            return empty_return
+
+        try:
+            summary = self.current_analysis.get('financial_summary', {})
+            insights = self.current_analysis.get('spending_insights', [])
+
+            # Summary metrics
+            total_income = summary.get('total_income', 0)
+            total_expenses = summary.get('total_expenses', 0)
+            net_cashflow = summary.get('net_cash_flow', 0)
+            transaction_count = self.current_analysis.get('transaction_count', 0)
+
+            # Create charts
+            charts = self._create_charts(insights, summary)
+
+            # Create insights HTML
+            insights_html = self._create_insights_html()
+
+            # Create transaction table
+            transaction_df = self._create_transaction_dataframe()
+
+            return (total_income, total_expenses, net_cashflow, transaction_count,
+                   charts['spending_by_category'], charts['monthly_trends'], 
+                   charts['income_vs_expenses'], charts['top_merchants'],
+                   insights_html['budget_alerts'], insights_html['spending_insights'],
+                   insights_html['recommendations'], insights_html['unusual_transactions'],
+                   transaction_df)
+
+        except Exception as e:
+            error_msg = f'<div class="status-box error-box"> Dashboard error: {str(e)}</div>'
+            empty_return = (0, 0, 0, 0, None, None, None, None,
+                          error_msg, error_msg, error_msg, error_msg, pd.DataFrame())
+            return empty_return
+
+    def _create_charts(self, insights, summary):
+        """Create visualization charts"""
+        charts = {}
+
+        # Spending by category chart
+        if insights:
+            categories = [insight['category'] for insight in insights]
+            amounts = [insight['total_amount'] for insight in insights]
+
+            charts['spending_by_category'] = px.pie(
+                values=amounts,
+                names=categories,
+                title="Spending by Category"
+            )
+        else:
+            charts['spending_by_category'] = None
+
+        # Monthly trends (placeholder)
+        charts['monthly_trends'] = None
+        charts['income_vs_expenses'] = None
+        charts['top_merchants'] = None
+
+        return charts
+
+    def _create_insights_html(self):
+        """Create insights HTML sections"""
+        insights = {}
+
+        if not self.current_analysis:
+            # Return empty insights if no analysis available
+            insights['budget_alerts'] = '<div class="status-box warning-box"> No analysis data available</div>'
+            insights['spending_insights'] = '<div class="status-box warning-box"> No analysis data available</div>'
+            insights['recommendations'] = '<div class="status-box warning-box"> No analysis data available</div>'
+            insights['unusual_transactions'] = '<div class="status-box warning-box"> No analysis data available</div>'
+            return insights
+
+        # Budget alerts
+        budget_alerts = self.current_analysis.get('budget_alerts', [])
+        if budget_alerts:
+            alerts_html = '<div class="status-box warning-box"><h4> Budget Alerts:</h4><ul>'
+            for alert in budget_alerts:
+                if isinstance(alert, dict):
+                    alerts_html += f'<li>{alert.get("category", "Unknown")}: {alert.get("percentage_used", 0):.1f}% used</li>'
+            alerts_html += '</ul></div>'
+        else:
+            alerts_html = '<div class="status-box success-box"> All budgets on track</div>'
+
+        insights['budget_alerts'] = alerts_html
+
+        # Spending insights
+        spending_insights = self.current_analysis.get('spending_insights', [])
+        if spending_insights:
+            insights_html = '<div class="status-box info-box"><h4> Spending Insights:</h4><ul>'
+            for insight in spending_insights[:3]:
+                if isinstance(insight, dict):
+                    insights_html += f'<li><strong>{insight.get("category", "Unknown")}:</strong> ${insight.get("total_amount", 0):.2f} ({insight.get("percentage_of_total", 0):.1f}%)</li>'
+            insights_html += '</ul></div>'
+        else:
+            insights_html = '<div class="status-box">No spending insights available</div>'
+
+        insights['spending_insights'] = insights_html
+
+        # Recommendations
+        recommendations = self.current_analysis.get('recommendations', [])
+        if recommendations:
+            rec_html = '<div class="status-box info-box"><h4> Recommendations:</h4><ul>'
+            for rec in recommendations[:3]:
+                if rec:  # Check if recommendation is not None/empty
+                    rec_html += f'<li>{rec}</li>'
+            rec_html += '</ul></div>'
+        else:
+            rec_html = '<div class="status-box">No specific recommendations available</div>'
+
+        insights['recommendations'] = rec_html
+
+        # Unusual transactions
+        financial_summary = self.current_analysis.get('financial_summary', {})
+        unusual = financial_summary.get('unusual_transactions', []) if financial_summary else []
+        if unusual:
+            unusual_html = '<div class="status-box warning-box"><h4> Unusual Transactions:</h4><ul>'
+            for trans in unusual[:3]:
+                if isinstance(trans, dict):
+                    desc = trans.get("description", "Unknown")
+                    amount = trans.get("amount", 0)
+                    unusual_html += f'<li>{desc}: ${amount:.2f}</li>'
+            unusual_html += '</ul></div>'
+        else:
+            unusual_html = '<div class="status-box success-box"> No unusual transactions detected</div>'
+
+        insights['unusual_transactions'] = unusual_html
+
+        return insights
+
+    def _create_transaction_dataframe(self):
+        """Create transaction dataframe for display"""
+        # This would create a dataframe from the actual transactions
+        # For now, return empty dataframe
+        return pd.DataFrame(columns=["Date", "Description", "Amount", "Category", "Account"])
+
+    def _handle_chat_message(self, message, chat_history, response_style):
+        """Handle chat messages"""
+        if not message.strip():
+            return chat_history, "", '<div class="status-box warning-box"> Please enter a message</div>'
+
+        # Simple response generation based on analysis
+        if self.current_analysis:
+            summary = self.current_analysis.get('financial_summary', {})
+
+            response = f"Based on your financial data: Total income ${summary.get('total_income', 0):.2f}, Total expenses ${summary.get('total_expenses', 0):.2f}. Your question: '{message}' - This is a simplified response. Full AI integration would provide detailed insights here."
+
+            status_html = '<div class="status-box success-box"> Response generated</div>'
+        else:
+            response = "Please upload and process your PDF statements first to get personalized financial insights."
+            status_html = '<div class="status-box warning-box"> No data available</div>'
+
+        # Add to chat history
+        chat_history = chat_history or []
+        chat_history.append([message, response])
+
+        return chat_history, "", status_html
+
+    def _filter_transactions(self, date_from, date_to, category_filter, amount_filter):
+        """Filter transactions based on criteria"""
+        # Placeholder implementation
+        return pd.DataFrame(), '<div class="status-box info-box">Filtering functionality would be implemented here</div>'
+
+    def _update_transaction(self, transaction_id, new_category):
+        """Update transaction category"""
+        return '<div class="status-box success-box"> Transaction updated</div>', pd.DataFrame()
+
+    def _add_category(self, new_category):
+        """Add new transaction category"""
+        return '<div class="status-box success-box"> Category added</div>', gr.update(), gr.update()
+
+    def _save_budget_settings(self, categories, amounts):
+        """Save budget settings"""
+        try:
+            budget_settings = {cat: amounts.get(cat, 0) for cat in categories}
+            self.user_sessions['budgets'] = budget_settings
+
+            # Apply budgets to analyzer
+            self.spend_analyzer.set_budgets(budget_settings)
+
+            status_html = '<div class="status-box success-box"> Budget settings saved and applied</div>'
+            return status_html, budget_settings
+
+        except Exception as e:
+            error_html = f'<div class="status-box error-box"> Error saving budgets: {str(e)}</div>'
+            return error_html, {}
+
+    def _export_data(self, export_format, export_options, date_range):
+        """Export analysis data"""
+        if not self.current_analysis:
+            return '<div class="status-box error-box"> No data to export</div>', {}, None
+
+        try:
+            # Create export data
+            export_data = {}
+
+            if "Analysis Summary" in export_options:
+                export_data['summary'] = self.current_analysis.get('financial_summary', {})
+
+            if "Raw Transactions" in export_options:
+                export_data['transactions'] = []  # Would populate with actual transaction data
+
+            # Create temporary file
+            with tempfile.NamedTemporaryFile(mode='w', suffix=f'.{export_format.lower()}', delete=False) as f:
+                if export_format == "JSON":
+                    json.dump(export_data, f, indent=2, default=str)
+                elif export_format == "CSV":
+                    # Would create CSV format
+                    f.write("Export functionality would create CSV here")
+
+                file_path = f.name
+
+            status_html = '<div class="status-box success-box"> Data exported successfully</div>'
+            return status_html, export_data, file_path
+
+        except Exception as e:
+            error_html = f'<div class="status-box error-box"> Export error: {str(e)}</div>'
+            return error_html, {}, None
+
+    def _save_processing_settings(self, settings):
+        """Save processing settings"""
+        try:
+            self.user_sessions['processing_settings'] = settings
+            return '<div class="status-box success-box"> Processing settings saved</div>'
+        except Exception as e:
+            return f'<div class="status-box error-box"> Error saving settings: {str(e)}</div>'
+
+    def _export_analysis(self):
+        """Export current analysis"""
+        if not self.current_analysis:
+            return None
+
+        try:
+            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+                json.dump(self.current_analysis, f, indent=2, default=str)
+                return f.name
+        except Exception as e:
+            self.logger.error(f"Export error: {e}")
+            return None
+
+    def _clear_data(self):
+        """Clear all data"""
+        self.current_analysis = None
+        self.spend_analyzer = SpendAnalyzer()  # Reset analyzer
+
+        return ('<div class="status-box success-box"> All data cleared</div>',
+                '<div class="status-box info-box"> Ready for new PDF upload</div>')
+
+# Launch the interface
+def launch_interface():
+    """Launch the Gradio interface"""
+    interface = RealSpendAnalyzerInterface()
+    app = interface.create_interface()
+
+    print(" Starting Spend Analyzer MCP - Real PDF Processing")
+    print(" Upload your bank statement PDFs for analysis")
+    print(" Opening in browser...")
+
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7862,
+        share=False,
+        debug=True,
+        show_error=True,
+        inbrowser=True
+    )
+
+if __name__ == "__main__":
+    launch_interface()

mcp_server.py

@@ -0,0 +1,225 @@
+"""
+MCP Server for Spend Analysis - Core Protocol Implementation
+"""
+import json
+import asyncio
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass
+from enum import Enum
+import logging
+
+# MCP Protocol Types
+class MessageType(Enum):
+    REQUEST = "request"
+    RESPONSE = "response"
+    NOTIFICATION = "notification"
+
+@dataclass
+class MCPMessage:
+    jsonrpc: str = "2.0"
+    id: Optional[str] = None
+    method: Optional[str] = None
+    params: Optional[Dict] = None
+    result: Optional[Any] = None
+    error: Optional[Dict] = None
+
+class MCPServer:
+    def __init__(self):
+        self.tools = {}
+        self.resources = {}
+        self.prompts = {}
+        self.logger = logging.getLogger(__name__)
+        
+    def register_tool(self, name: str, description: str, handler):
+        """Register a tool that Claude can call"""
+        self.tools[name] = {
+            "description": description,
+            "handler": handler,
+            "input_schema": {
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        }
+    
+    def register_resource(self, uri: str, name: str, description: str, handler):
+        """Register a resource that provides data"""
+        self.resources[uri] = {
+            "name": name,
+            "description": description,
+            "handler": handler,
+            "mimeType": "application/json"
+        }
+    
+    async def handle_message(self, message: Dict) -> Dict:
+        """Handle incoming MCP messages"""
+        try:
+            method = message.get("method")
+            params = message.get("params", {})
+            msg_id = message.get("id")
+            
+            if method == "initialize":
+                return self._handle_initialize(msg_id)
+            elif method == "tools/list":
+                return self._handle_list_tools(msg_id)
+            elif method == "tools/call":
+                return await self._handle_call_tool(msg_id, params)
+            elif method == "resources/list":
+                return self._handle_list_resources(msg_id)
+            elif method == "resources/read":
+                return await self._handle_read_resource(msg_id, params)
+            else:
+                return self._error_response(msg_id, -32601, f"Method not found: {method}")
+                
+        except Exception as e:
+            self.logger.error(f"Error handling message: {e}")
+            return self._error_response(message.get("id"), -32603, str(e))
+    
+    def _handle_initialize(self, msg_id: str) -> Dict:
+        """Handle MCP initialization"""
+        return {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {
+                    "tools": {},
+                    "resources": {},
+                    "prompts": {}
+                },
+                "serverInfo": {
+                    "name": "spend-analyzer-mcp",
+                    "version": "1.0.0"
+                }
+            }
+        }
+    
+    def _handle_list_tools(self, msg_id: str) -> Dict:
+        """List available tools"""
+        tools_list = []
+        for name, tool in self.tools.items():
+            tools_list.append({
+                "name": name,
+                "description": tool["description"],
+                "inputSchema": tool["input_schema"]
+            })
+        
+        return {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {"tools": tools_list}
+        }
+    
+    async def _handle_call_tool(self, msg_id: str, params: Dict) -> Dict:
+        """Execute a tool call"""
+        tool_name = params.get("name")
+        arguments = params.get("arguments", {})
+        
+        if tool_name not in self.tools:
+            return self._error_response(msg_id, -32602, f"Tool not found: {tool_name}")
+        
+        try:
+            handler = self.tools[tool_name]["handler"]
+            result = await handler(arguments)
+            return {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "result": {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": json.dumps(result)
+                        }
+                    ]
+                }
+            }
+        except Exception as e:
+            return self._error_response(msg_id, -32603, f"Tool execution failed: {str(e)}")
+    
+    def _handle_list_resources(self, msg_id: str) -> Dict:
+        """List available resources"""
+        resources_list = []
+        for uri, resource in self.resources.items():
+            resources_list.append({
+                "uri": uri,
+                "name": resource["name"],
+                "description": resource["description"],
+                "mimeType": resource["mimeType"]
+            })
+        
+        return {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "result": {"resources": resources_list}
+        }
+    
+    async def _handle_read_resource(self, msg_id: str, params: Dict) -> Dict:
+        """Read a resource"""
+        uri = params.get("uri")
+        
+        if uri not in self.resources:
+            return self._error_response(msg_id, -32602, f"Resource not found: {uri}")
+        
+        try:
+            handler = self.resources[uri]["handler"]
+            content = await handler()
+            return {
+                "jsonrpc": "2.0",
+                "id": msg_id,
+                "result": {
+                    "contents": [
+                        {
+                            "uri": uri,
+                            "mimeType": "application/json",
+                            "text": json.dumps(content, indent=2)
+                        }
+                    ]
+                }
+            }
+        except Exception as e:
+            return self._error_response(msg_id, -32603, f"Resource read failed: {str(e)}")
+    
+    def _error_response(self, msg_id: str, code: int, message: str) -> Dict:
+        """Create error response"""
+        return {
+            "jsonrpc": "2.0",
+            "id": msg_id,
+            "error": {
+                "code": code,
+                "message": message
+            }
+        }
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Test the MCP server
+    server = MCPServer()
+    
+    # Register a simple tool
+    async def test_tool(args):
+        return f"Test tool called with: {args}"
+    
+    server.register_tool("test", "A test tool", test_tool)
+    
+    # Test message handling
+    async def test_server():
+        init_msg = {
+            "jsonrpc": "2.0",
+            "id": "1",
+            "method": "initialize",
+            "params": {}
+        }
+        
+        response = await server.handle_message(init_msg)
+        print("Initialize response:", json.dumps(response, indent=2))
+        
+        list_tools_msg = {
+            "jsonrpc": "2.0",
+            "id": "2",
+            "method": "tools/list"
+        }
+        
+        response = await server.handle_message(list_tools_msg)
+        print("List tools response:", json.dumps(response, indent=2))
+    
+    asyncio.run(test_server())

modal_deployment.py

@@ -0,0 +1,392 @@
+"""
+Modal.com Deployment Configuration for Spend Analyzer MCP
+"""
+import modal
+import os
+from typing import Dict, Any, Optional
+import json
+import asyncio
+from datetime import datetime
+import logging
+
+# Create Modal app
+app = modal.App("spend-analyzer-mcp")
+
+# Define the container image with all dependencies
+image = (
+    modal.Image.debian_slim(python_version="3.11")
+    .pip_install([
+        "fastapi",
+        "uvicorn",
+        "gradio",
+        "pandas",
+        "numpy",
+        "PyPDF2",
+        "PyMuPDF",
+        "anthropic",
+        "python-multipart",
+        "aiofiles",
+        "python-dotenv",
+        "imaplib2",
+        "email-validator",
+        "pydantic",
+        "websockets",
+        "asyncio-mqtt"
+    ])
+    .apt_install(["tesseract-ocr", "tesseract-ocr-eng"])
+)
+
+# Secrets for API keys and email credentials
+secrets = [
+    modal.Secret.from_name("anthropic-api-key"),  # ANTHROPIC_API_KEY
+    modal.Secret.from_name("email-credentials"),  # EMAIL_USER, EMAIL_PASS, IMAP_SERVER
+]
+
+# Shared volume for persistent storage
+volume = modal.Volume.from_name("spend-analyzer-data", create_if_missing=True)
+
+@app.function(
+    image=image,
+    secrets=secrets,
+    volumes={"/data": volume},
+    timeout=300,
+    memory=2048,
+    cpu=2.0
+)
+def process_bank_statements(email_config: Dict, days_back: int = 30, passwords: Optional[Dict] = None):
+    """
+    Modal function to process bank statements from email
+    """
+    import sys
+    sys.path.append("/data")
+    
+    from email_processor import EmailProcessor, PDFProcessor
+    from spend_analyzer import SpendAnalyzer
+    
+    try:
+        # Initialize processors
+        email_processor = EmailProcessor(email_config)
+        pdf_processor = PDFProcessor()
+        analyzer = SpendAnalyzer()
+        
+        # Fetch emails
+        emails = asyncio.run(email_processor.fetch_bank_emails(days_back))
+        
+        all_transactions = []
+        processed_statements = []
+        
+        for email_msg in emails:
+            try:
+                # Extract attachments
+                attachments = asyncio.run(email_processor.extract_attachments(email_msg))
+                
+                for filename, content, file_type in attachments:
+                    if file_type == 'pdf':
+                        # Try to process PDF
+                        password = None
+                        if passwords and filename in passwords:
+                            password = passwords[filename]
+                        
+                        try:
+                            statement_info = asyncio.run(pdf_processor.process_pdf(content, password))
+                            all_transactions.extend(statement_info.transactions)
+                            processed_statements.append({
+                                'filename': filename,
+                                'bank': statement_info.bank_name,
+                                'account': statement_info.account_number,
+                                'period': statement_info.statement_period,
+                                'transaction_count': len(statement_info.transactions)
+                            })
+                            
+                        except ValueError as e:
+                            if "password" in str(e).lower():
+                                # PDF requires password
+                                processed_statements.append({
+                                    'filename': filename,
+                                    'status': 'password_required',
+                                    'error': str(e)
+                                })
+                            else:
+                                processed_statements.append({
+                                    'filename': filename,
+                                    'status': 'error',
+                                    'error': str(e)
+                                })
+                                
+            except Exception as e:
+                logging.error(f"Error processing email: {e}")
+                continue
+        
+        # Analyze transactions
+        if all_transactions:
+            analyzer.load_transactions(all_transactions)
+            analysis_data = analyzer.export_analysis_data()
+        else:
+            analysis_data = {'message': 'No transactions found'}
+        
+        return {
+            'processed_statements': processed_statements,
+            'total_transactions': len(all_transactions),
+            'analysis': analysis_data,
+            'timestamp': datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        logging.error(f"Error in process_bank_statements: {e}")
+        return {'error': str(e)}
+
+@app.function(
+    image=image,
+    secrets=secrets,
+    timeout=60
+)
+def analyze_uploaded_statements(pdf_contents: Dict[str, bytes], passwords: Optional[Dict] = None):
+    """
+    Modal function to analyze directly uploaded PDF statements
+    """
+    from pdf_processor import PDFProcessor
+    from spend_analyzer import SpendAnalyzer
+    
+    try:
+        pdf_processor = PDFProcessor()
+        analyzer = SpendAnalyzer()
+        
+        all_transactions = []
+        processed_files = []
+        
+        for filename, content in pdf_contents.items():
+            try:
+                password = passwords.get(filename) if passwords else None
+                statement_info = asyncio.run(pdf_processor.process_pdf(content, password))
+                
+                all_transactions.extend(statement_info.transactions)
+                processed_files.append({
+                    'filename': filename,
+                    'bank': statement_info.bank_name,
+                    'account': statement_info.account_number,
+                    'transaction_count': len(statement_info.transactions),
+                    'status': 'success'
+                })
+                
+            except Exception as e:
+                processed_files.append({
+                    'filename': filename,
+                    'status': 'error',
+                    'error': str(e)
+                })
+        
+        # Analyze transactions
+        if all_transactions:
+            analyzer.load_transactions(all_transactions)
+            analysis_data = analyzer.export_analysis_data()
+        else:
+            analysis_data = {'message': 'No transactions found'}
+        
+        return {
+            'processed_files': processed_files,
+            'total_transactions': len(all_transactions),
+            'analysis': analysis_data
+        }
+        
+    except Exception as e:
+        return {'error': str(e)}
+
+@app.function(
+    image=image,
+    secrets=secrets,
+    volumes={"/data": volume},
+    timeout=30
+)
+def get_claude_analysis(analysis_data: Dict, user_question: str = ""):
+    """
+    Modal function to get Claude's analysis of spending data
+    """
+    import anthropic
+    
+    try:
+        client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
+        
+        # Prepare context for Claude
+        context = f"""
+        Financial Analysis Data:
+        {json.dumps(analysis_data, indent=2, default=str)}
+        
+        User Question: {user_question if user_question else "Please provide a comprehensive analysis of my spending patterns and recommendations."}
+        """
+        
+        response = client.messages.create(
+            model="claude-3-sonnet-20240229",
+            max_tokens=1500,
+            messages=[
+                {
+                    "role": "user",
+                    "content": f"""
+                    You are a financial advisor analyzing bank statement data. 
+                    Based on the provided financial data, give insights about:
+                    
+                    1. Spending patterns and trends
+                    2. Budget adherence and alerts
+                    3. Unusual transactions that need attention
+                    4. Specific recommendations for improvement
+                    5. Answer to the user's specific question if provided
+                    
+                    Be specific, actionable, and highlight both positive aspects and areas for improvement.
+                    
+                    {context}
+                    """
+                }
+            ]
+        )
+        
+        return {
+            'claude_analysis': response.content[0].text,
+            'usage': response.usage.input_tokens + response.usage.output_tokens
+        }
+        
+    except Exception as e:
+        return {'error': f"Claude API error: {str(e)}"}
+
+@app.function(
+    image=image,
+    volumes={"/data": volume},
+    timeout=30
+)
+def save_user_data(user_id: str, data: Dict):
+    """
+    Save user analysis data to persistent storage
+    """
+    try:
+        import json
+        import os
+        
+        user_dir = f"/data/users/{user_id}"
+        os.makedirs(user_dir, exist_ok=True)
+        
+        # Save analysis data
+        with open(f"{user_dir}/analysis.json", "w") as f:
+            json.dump(data, f, indent=2, default=str)
+        
+        # Save timestamp
+        with open(f"{user_dir}/last_updated.txt", "w") as f:
+            f.write(datetime.now().isoformat())
+        
+        return {"status": "saved", "path": user_dir}
+        
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.function(
+    image=image,
+    volumes={"/data": volume},
+    timeout=30
+)
+def load_user_data(user_id: str):
+    """
+    Load user analysis data from persistent storage
+    """
+    try:
+        import json
+        
+        user_dir = f"/data/users/{user_id}"
+        analysis_file = f"{user_dir}/analysis.json"
+        
+        if os.path.exists(analysis_file):
+            with open(analysis_file, "r") as f:
+                data = json.load(f)
+            
+            # Get last updated time
+            last_updated = None
+            if os.path.exists(f"{user_dir}/last_updated.txt"):
+                with open(f"{user_dir}/last_updated.txt", "r") as f:
+                    last_updated = f.read().strip()
+            
+            return {
+                "data": data,
+                "last_updated": last_updated,
+                "status": "found"
+            }
+        else:
+            return {"status": "not_found"}
+            
+    except Exception as e:
+        return {"error": str(e)}
+
+# Webhook endpoint for MCP integration
+@app.function(
+    image=image,
+    secrets=secrets,
+    volumes={"/data": volume}
+)
+@modal.web_endpoint(method="POST")
+def mcp_webhook(request_data: Dict):
+    """
+    Webhook endpoint for MCP protocol messages
+    """
+    try:
+        from mcp_server import MCPServer
+        
+        # Initialize MCP server
+        server = MCPServer()
+        
+        # Register tools
+        async def process_statements_tool(args):
+            email_config = args.get('email_config', {})
+            days_back = args.get('days_back', 30)
+            passwords = args.get('passwords', {})
+            
+            result = process_bank_statements.remote(email_config, days_back, passwords)
+            return result
+        
+        async def analyze_pdf_tool(args):
+            pdf_contents = args.get('pdf_contents', {})
+            passwords = args.get('passwords', {})
+            
+            result = analyze_uploaded_statements.remote(pdf_contents, passwords)
+            return result
+        
+        async def get_analysis_tool(args):
+            analysis_data = args.get('analysis_data', {})
+            user_question = args.get('user_question', '')
+            
+            result = get_claude_analysis.remote(analysis_data, user_question)
+            return result
+        
+        # Register tools with MCP server
+        server.register_tool("process_email_statements", "Process bank statements from email", process_statements_tool)
+        server.register_tool("analyze_pdf_statements", "Analyze uploaded PDF statements", analyze_pdf_tool)
+        server.register_tool("get_claude_analysis", "Get Claude's financial analysis", get_analysis_tool)
+        
+        # Handle MCP message
+        response = asyncio.run(server.handle_message(request_data))
+        return response
+        
+    except Exception as e:
+        return {
+            "jsonrpc": "2.0",
+            "id": request_data.get("id"),
+            "error": {
+                "code": -32603,
+                "message": str(e)
+            }
+        }
+
+# CLI for local testing
+@app.local_entrypoint()
+def main():
+    """
+    Local entrypoint for testing Modal functions
+    """
+    print("Testing Modal deployment...")
+    
+    # Test basic functionality
+    test_data = {
+        "spending_insights": [],
+        "recommendations": ["Test recommendation"]
+    }
+    
+    result = get_claude_analysis.remote(test_data, "What do you think about my spending?")
+    print("Claude analysis result:", result)
+
+if __name__ == "__main__":
+    # For running locally
+    modal.run(main)

requirements.txt

@@ -0,0 +1,20 @@
+# Core dependencies for Spend Analyzer MCP
+gradio>=4.0.0
+pandas>=1.5.0
+plotly>=5.0.0
+numpy>=1.21.0
+
+# PDF processing
+PyPDF2>=3.0.0
+PyMuPDF>=1.20.0
+
+# AI and API (optional)
+anthropic>=0.7.0
+
+# Async and utilities
+python-dotenv>=0.19.0
+pydantic>=1.10.0
+
+# Development and testing (optional)
+uvicorn>=0.18.0
+fastapi>=0.85.0

setup_local.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Local setup script for Spend Analyzer MCP
+"""
+import os
+import sys
+import subprocess
+import logging
+
+def check_python_version():
+    """Check if Python version is compatible"""
+    if sys.version_info < (3, 8):
+        print("❌ Python 3.8 or higher is required")
+        return False
+    print(f"✅ Python {sys.version_info.major}.{sys.version_info.minor} detected")
+    return True
+
+def install_dependencies():
+    """Install required dependencies"""
+    print("📦 Installing dependencies...")
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
+        print("✅ Dependencies installed successfully")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to install dependencies: {e}")
+        return False
+
+def create_env_file():
+    """Create .env file template"""
+    env_content = """# Spend Analyzer MCP Environment Variables
+# Copy this file to .env and fill in your actual values
+
+# Claude API Key (optional for local demo)
+ANTHROPIC_API_KEY=your_claude_api_key_here
+
+# Email Configuration (optional for local demo)
+[email protected]
+EMAIL_PASS=your_app_password_here
+IMAP_SERVER=imap.gmail.com
+
+# Modal Configuration (optional)
+MODAL_TOKEN_ID=your_modal_token_id
+MODAL_TOKEN_SECRET=your_modal_token_secret
+"""
+    
+    if not os.path.exists('.env.template'):
+        with open('.env.template', 'w') as f:
+            f.write(env_content)
+        print("✅ Created .env.template file")
+        print("📝 Please copy .env.template to .env and fill in your API keys")
+    else:
+        print("✅ .env file already exists")
+
+def test_imports():
+    """Test if all required modules can be imported"""
+    print("🧪 Testing imports...")
+    
+    required_modules = [
+        'gradio',
+        'pandas', 
+        'plotly',
+        'numpy'
+    ]
+    
+    failed_imports = []
+    
+    for module in required_modules:
+        try:
+            __import__(module)
+            print(f"  ✅ {module}")
+        except ImportError:
+            print(f"  ❌ {module}")
+            failed_imports.append(module)
+    
+    if failed_imports:
+        print(f"\n❌ Failed to import: {', '.join(failed_imports)}")
+        print("💡 Try running: pip install -r requirements.txt")
+        return False
+    
+    print("✅ All required modules imported successfully")
+    return True
+
+def create_demo_data():
+    """Create demo data for testing"""
+    demo_data = {
+        "transactions": [
+            {
+                "date": "2024-01-15",
+                "description": "STARBUCKS COFFEE",
+                "amount": -4.50,
+                "category": "Food & Dining"
+            },
+            {
+                "date": "2024-01-14", 
+                "description": "AMAZON PURCHASE",
+                "amount": -29.99,
+                "category": "Shopping"
+            },
+            {
+                "date": "2024-01-13",
+                "description": "SALARY DEPOSIT",
+                "amount": 3000.00,
+                "category": "Income"
+            }
+        ]
+    }
+    
+    import json
+    with open('demo_data.json', 'w') as f:
+        json.dump(demo_data, f, indent=2)
+    
+    print("✅ Created demo_data.json for testing")
+
+def main():
+    """Main setup function"""
+    print("🚀 Setting up Spend Analyzer MCP locally...\n")
+    
+    # Check Python version
+    if not check_python_version():
+        return False
+    
+    # Install dependencies
+    if not install_dependencies():
+        return False
+    
+    # Test imports
+    if not test_imports():
+        return False
+    
+    # Create environment file template
+    create_env_file()
+    
+    # Create demo data
+    create_demo_data()
+    
+    print("\n🎉 Local setup completed successfully!")
+    print("\n📋 Next steps:")
+    print("1. Copy .env.template to .env and add your API keys (optional for demo)")
+    print("2. Run: python gradio_interface.py")
+    print("3. Open http://localhost:7860 in your browser")
+    print("\n💡 The app will work in demo mode without API keys")
+    
+    return True
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

spend_analyzer.py

@@ -0,0 +1,486 @@
+"""
+Spend Analyzer - Financial Intelligence and Analysis Module
+"""
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime, timedelta
+from dataclasses import dataclass, asdict
+import json
+from collections import defaultdict
+import logging
+
+@dataclass
+class SpendingInsight:
+    category: str
+    total_amount: float
+    transaction_count: int
+    average_transaction: float
+    percentage_of_total: float
+    trend: str  # 'increasing', 'decreasing', 'stable'
+    top_merchants: List[str]
+
+@dataclass
+class BudgetAlert:
+    category: str
+    budget_limit: float
+    current_spending: float
+    percentage_used: float
+    alert_level: str  # 'warning', 'critical', 'info'
+    days_remaining: int
+
+@dataclass
+class FinancialSummary:
+    total_income: float
+    total_expenses: float
+    net_cash_flow: float
+    largest_expense: Dict
+    most_frequent_category: str
+    unusual_transactions: List[Dict]
+    monthly_trends: Dict[str, float]
+
+class SpendAnalyzer:
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.transactions_df = pd.DataFrame()
+        self.budgets = {}
+        
+    def load_transactions(self, transactions: List) -> None:
+        """Load transactions into pandas DataFrame for analysis"""
+        try:
+            # Convert transactions to DataFrame
+            data = []
+            for trans in transactions:
+                if hasattr(trans, '__dict__'):
+                    data.append(asdict(trans))
+                else:
+                    data.append(trans)
+            
+            self.transactions_df = pd.DataFrame(data)
+            
+            if not self.transactions_df.empty:
+                # Ensure date column is datetime
+                self.transactions_df['date'] = pd.to_datetime(self.transactions_df['date'])
+                
+                # Sort by date
+                self.transactions_df = self.transactions_df.sort_values('date')
+                
+                # Add derived columns
+                self.transactions_df['month'] = self.transactions_df['date'].dt.to_period('M')
+                self.transactions_df['week'] = self.transactions_df['date'].dt.to_period('W')
+                self.transactions_df['day_of_week'] = self.transactions_df['date'].dt.day_name()
+                
+                self.logger.info(f"Loaded {len(self.transactions_df)} transactions")
+                
+        except Exception as e:
+            self.logger.error(f"Error loading transactions: {e}")
+            raise
+    
+    def set_budgets(self, budgets: Dict[str, float]) -> None:
+        """Set budget limits for categories"""
+        self.budgets = budgets
+    
+    def analyze_spending_by_category(self, months_back: int = 6) -> List[SpendingInsight]:
+        """Analyze spending patterns by category"""
+        if self.transactions_df.empty:
+            return []
+        
+        # Filter to recent months
+        cutoff_date = datetime.now() - timedelta(days=months_back * 30)
+        recent_df = self.transactions_df[self.transactions_df['date'] >= cutoff_date]
+        
+        # Filter only expenses (negative amounts)
+        expenses_df = recent_df[recent_df['amount'] < 0].copy()
+        expenses_df['amount'] = expenses_df['amount'].abs()  # Make positive for analysis
+        
+        insights = []
+        total_spending = expenses_df['amount'].sum()
+        
+        if total_spending == 0:
+            self.logger.warning("Total spending is zero; no insights can be generated.")
+            return insights
+        
+        # Group by category
+        category_stats = expenses_df.groupby('category').agg({
+            'amount': ['sum', 'count', 'mean'],
+            'description': lambda x: list(x.value_counts().head(3).index)
+        }).round(2)
+        
+        category_stats.columns = ['total', 'count', 'average', 'top_merchants']
+        
+        for category, stats in category_stats.iterrows():
+            # Calculate trend
+            trend = self._calculate_trend(expenses_df, category)
+            
+            insight = SpendingInsight(
+                category=category,
+                total_amount=stats['total'],
+                transaction_count=stats['count'],
+                average_transaction=stats['average'],
+                percentage_of_total=(stats['total'] / total_spending) * 100,
+                trend=trend,
+                top_merchants=stats['top_merchants'][:3]
+            )
+            insights.append(insight)
+        
+        # Sort by total amount descending
+        insights.sort(key=lambda x: x.total_amount, reverse=True)
+        return insights
+    
+    def _calculate_trend(self, df: pd.DataFrame, category: str) -> str:
+        """Calculate spending trend for a category"""
+        try:
+            category_df = df[df['category'] == category]
+            monthly_spending = category_df.groupby('month')['amount'].sum()
+            
+            if len(monthly_spending) < 2:
+                return 'stable'
+            
+            # Calculate trend using linear regression slope
+            x = np.arange(len(monthly_spending))
+            y = monthly_spending.values
+            slope = np.polyfit(x, y, 1)[0]
+            
+            if slope > 0.1:
+                return 'increasing'
+            elif slope < -0.1:
+                return 'decreasing'
+            else:
+                return 'stable'
+                
+        except Exception:
+            return 'stable'
+    
+    def check_budget_alerts(self) -> List[BudgetAlert]:
+        """Check for budget alerts and overspending"""
+        if self.transactions_df.empty or not self.budgets:
+            return []
+        
+        alerts = []
+        current_month = datetime.now().replace(day=1)
+        month_df = self.transactions_df[
+            (self.transactions_df['date'] >= current_month) &
+            (self.transactions_df['amount'] < 0)  # Only expenses
+        ].copy()
+        
+        month_df['amount'] = month_df['amount'].abs()
+        
+        # Days remaining in month
+        import calendar
+        days_in_month = calendar.monthrange(current_month.year, current_month.month)[1]
+        days_remaining = days_in_month - datetime.now().day
+        
+        # Check each budget category
+        for category, budget_limit in self.budgets.items():
+            current_spending = month_df[month_df['category'] == category]['amount'].sum()
+            percentage_used = (current_spending / budget_limit) * 100
+            
+            # Determine alert level
+            if percentage_used >= 100:
+                alert_level = 'critical'
+            elif percentage_used >= 80:
+                alert_level = 'warning'
+            else:
+                alert_level = 'info'
+            
+            alert = BudgetAlert(
+                category=category,
+                budget_limit=budget_limit,
+                current_spending=current_spending,
+                percentage_used=percentage_used,
+                alert_level=alert_level,
+                days_remaining=days_remaining
+            )
+            alerts.append(alert)
+        
+        return alerts
+    
+    def generate_financial_summary(self) -> FinancialSummary:
+        """Generate comprehensive financial summary"""
+        if self.transactions_df.empty:
+            return FinancialSummary(0, 0, 0, {}, "", [], {})
+        
+        # Calculate basic metrics
+        income_df = self.transactions_df[self.transactions_df['amount'] > 0]
+        expense_df = self.transactions_df[self.transactions_df['amount'] < 0]
+        
+        total_income = income_df['amount'].sum()
+        total_expenses = abs(expense_df['amount'].sum())
+        net_cash_flow = total_income - total_expenses
+        
+        # Largest expense
+        if not expense_df.empty:
+            largest_expense_row = expense_df.loc[expense_df['amount'].idxmin()]
+            largest_expense = {
+                'amount': abs(largest_expense_row['amount']),
+                'description': largest_expense_row['description'],
+                'date': largest_expense_row['date'].strftime('%Y-%m-%d'),
+                'category': largest_expense_row['category']
+            }
+        else:
+            largest_expense = {}
+        
+        # Most frequent category
+        most_frequent_category = expense_df['category'].mode().iloc[0] if not expense_df.empty else ""
+        
+        # Unusual transactions (outliers)
+        unusual_transactions = self._detect_unusual_transactions()
+        
+        # Monthly trends
+        monthly_trends = self._calculate_monthly_trends()
+        
+        return FinancialSummary(
+            total_income=total_income,
+            total_expenses=total_expenses,
+            net_cash_flow=net_cash_flow,
+            largest_expense=largest_expense,
+            most_frequent_category=most_frequent_category,
+            unusual_transactions=unusual_transactions,
+            monthly_trends=monthly_trends
+        )
+    
+    def _detect_unusual_transactions(self) -> List[Dict]:
+        """Detect unusual transactions using statistical methods"""
+        if self.transactions_df.empty:
+            return []
+        
+        unusual = []
+        
+        # Detect amount outliers by category
+        for category in self.transactions_df['category'].unique():
+            category_df = self.transactions_df[
+                (self.transactions_df['category'] == category) & 
+                (self.transactions_df['amount'] < 0)
+            ].copy()
+            
+            if len(category_df) < 5:  # Need sufficient data
+                continue
+            
+            amounts = category_df['amount'].abs()
+            Q1 = amounts.quantile(0.25)
+            Q3 = amounts.quantile(0.75)
+            IQR = Q3 - Q1
+            
+            # Define outliers as values beyond 1.5 * IQR
+            lower_bound = Q1 - 1.5 * IQR
+            upper_bound = Q3 + 1.5 * IQR
+            
+            outliers = category_df[(amounts < lower_bound) | (amounts > upper_bound)]
+            
+            for _, row in outliers.iterrows():
+                unusual.append({
+                    'date': row['date'].strftime('%Y-%m-%d'),
+                    'description': row['description'],
+                    'amount': abs(row['amount']),
+                    'category': row['category'],
+                    'reason': 'Amount significantly higher than usual for this category'
+                })
+        
+        # Detect frequency outliers (multiple transactions same day/merchant)
+        daily_merchant = self.transactions_df.groupby([
+            self.transactions_df['date'].dt.date, 'description'
+        ]).size()
+        
+        frequent_same_day = daily_merchant[daily_merchant > 3]
+        
+        for (date, merchant), count in frequent_same_day.items():
+            unusual.append({
+                'date': str(date),
+                'description': merchant,
+                'count': count,
+                'reason': f'{count} transactions with same merchant on same day'
+            })
+        
+        return unusual[:10]  # Return top 10 unusual transactions
+    
+    def _calculate_monthly_trends(self) -> Dict[str, float]:
+        """Calculate monthly spending trends"""
+        if self.transactions_df.empty:
+            return {}
+        
+        # Get last 12 months of expense data
+        expense_df = self.transactions_df[self.transactions_df['amount'] < 0].copy()
+        expense_df['amount'] = expense_df['amount'].abs()
+        
+        monthly_spending = expense_df.groupby('month')['amount'].sum()
+        
+        # Get last 6 months for trend calculation
+        recent_months = monthly_spending.tail(6)
+        
+        trends = {}
+        if len(recent_months) >= 2:
+            # Overall trend
+            x = np.arange(len(recent_months))
+            y = recent_months.values
+            slope = np.polyfit(x, y, 1)[0]
+            trends['overall_trend'] = slope
+            
+            # Month-over-month change
+            if len(recent_months) >= 2:
+                current_month = recent_months.iloc[-1]
+                previous_month = recent_months.iloc[-2]
+                mom_change = ((current_month - previous_month) / previous_month) * 100
+                trends['month_over_month_change'] = mom_change
+            
+            # Average monthly spending
+            trends['average_monthly'] = recent_months.mean()
+            trends['highest_month'] = recent_months.max()
+            trends['lowest_month'] = recent_months.min()
+        
+        return trends
+    
+    def predict_future_spending(self, months_ahead: int = 3) -> Dict[str, float]:
+        """Predict future spending based on historical trends"""
+        if self.transactions_df.empty:
+            return {}
+        
+        # Get historical monthly spending by category
+        expense_df = self.transactions_df[self.transactions_df['amount'] < 0].copy()
+        expense_df['amount'] = expense_df['amount'].abs()
+        
+        monthly_category_spending = expense_df.groupby(['month', 'category'])['amount'].sum().unstack(fill_value=0)
+        
+        predictions = {}
+        
+        for category in monthly_category_spending.columns:
+            category_data = monthly_category_spending[category]
+            
+            if len(category_data) >= 3:  # Need at least 3 months of data
+                # Simple linear trend prediction
+                x = np.arange(len(category_data))
+                y = category_data.values
+                
+                # Fit linear model
+                coeffs = np.polyfit(x, y, 1)
+                slope, intercept = coeffs
+                
+                # Predict future months
+                future_months = []
+                for i in range(1, months_ahead + 1):
+                    future_x = len(category_data) + i - 1
+                    predicted_amount = slope * future_x + intercept
+                    future_months.append(max(0, predicted_amount))  # Don't predict negative spending
+                
+                predictions[category] = {
+                    'next_month': future_months[0] if future_months else 0,
+                    'total_predicted': sum(future_months),
+                    'average_predicted': np.mean(future_months) if future_months else 0
+                }
+        
+        return predictions
+    
+    def get_spending_recommendations(self) -> List[str]:
+        """Generate spending recommendations based on analysis"""
+        recommendations = []
+        
+        if self.transactions_df.empty:
+            return ["No transaction data available for analysis"]
+        
+        # Analyze spending patterns
+        insights = self.analyze_spending_by_category()
+        budget_alerts = self.check_budget_alerts()
+        summary = self.generate_financial_summary()
+        
+        # Check for overspending categories
+        overspending_categories = [alert for alert in budget_alerts if alert.percentage_used > 100]
+        if overspending_categories:
+            for alert in overspending_categories:
+                recommendations.append(
+                    f"You've exceeded your {alert.category} budget by "
+                    f"${alert.current_spending - alert.budget_limit:.2f} this month. "
+                    f"Consider reducing spending in this category."
+                )
+        
+        # Check for high-spending categories
+        if insights:
+            top_category = insights[0]
+            if top_category.percentage_of_total > 40:
+                recommendations.append(
+                    f"{top_category.category} accounts for {top_category.percentage_of_total:.1f}% "
+                    f"of your spending. Consider if this allocation aligns with your priorities."
+                )
+        
+        # Check cash flow
+        if summary.net_cash_flow < 0:
+            recommendations.append(
+                f"Your expenses (${summary.total_expenses:.2f}) exceed your income "
+                f"(${summary.total_income:.2f}) by ${abs(summary.net_cash_flow):.2f}. "
+                f"Focus on reducing expenses or increasing income."
+            )
+        
+        # Check for increasing trends
+        increasing_categories = [i for i in insights if i.trend == 'increasing']
+        if increasing_categories:
+            top_increasing = increasing_categories[0]
+            recommendations.append(
+                f"Your {top_increasing.category} spending is trending upward. "
+                f"Monitor this category to avoid budget overruns."
+            )
+        
+        # Unusual transaction patterns
+        if summary.unusual_transactions:
+            recommendations.append(
+                f"Found {len(summary.unusual_transactions)} unusual transactions. "
+                f"Review these for potential errors or unauthorized charges."
+            )
+        
+        # Positive reinforcement
+        decreasing_categories = [i for i in insights if i.trend == 'decreasing']
+        if decreasing_categories:
+            recommendations.append(
+                f"Great job reducing {decreasing_categories[0].category} spending! "
+                f"This trend is helping improve your financial health."
+            )
+        
+        if not recommendations:
+            recommendations.append("Your spending patterns look healthy. Keep up the good work!")
+        
+        return recommendations
+    
+    def export_analysis_data(self) -> Dict:
+        """Export all analysis data for Claude API integration"""
+        return {
+            'spending_insights': [asdict(insight) for insight in self.analyze_spending_by_category()],
+            'budget_alerts': [asdict(alert) for alert in self.check_budget_alerts()],
+            'financial_summary': asdict(self.generate_financial_summary()),
+            'predictions': self.predict_future_spending(),
+            'recommendations': self.get_spending_recommendations(),
+            'transaction_count': len(self.transactions_df),
+            'analysis_date': datetime.now().isoformat()
+        }
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Test the spend analyzer
+    analyzer = SpendAnalyzer()
+    
+    # Sample transaction data for testing
+    sample_transactions = [
+        {
+            'date': datetime.now() - timedelta(days=5),
+            'description': 'Amazon Purchase',
+            'amount': -45.67,
+            'category': 'Shopping'
+        },
+        {
+            'date': datetime.now() - timedelta(days=10),
+            'description': 'Grocery Store',
+            'amount': -120.50,
+            'category': 'Food & Dining'
+        },
+        {
+            'date': datetime.now() - timedelta(days=15),
+            'description': 'Salary Deposit',
+            'amount': 3000.00,
+            'category': 'Income'
+        }
+    ]
+    
+    analyzer.load_transactions(sample_transactions)
+    analyzer.set_budgets({'Shopping': 100, 'Food & Dining': 200})
+    
+    insights = analyzer.analyze_spending_by_category()
+    print(f"Generated {len(insights)} spending insights")
+    
+    recommendations = analyzer.get_spending_recommendations()
+    print(f"Generated {len(recommendations)} recommendations")