Update app.py

app.py

@@ -1,5 +1,5 @@
 
-import gradio as gr
+'''import gradio as gr
 import requests
 import json
 import plotly.graph_objects as go
@@ -520,4 +520,583 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         share=True
+    )'''
+
+
+import gradio as gr
+import requests
+import json
+import plotly.graph_objects as go
+import plotly.express as px
+from fastapi import FastAPI
+from typing import Dict, Any, Optional
+import os
+from datetime import datetime
+from utils import (
+    validate_salary, validate_expenses, calculate_50_30_20_breakdown,
+    calculate_emergency_fund_target, calculate_sip_returns, get_tax_saving_instruments,
+    get_investment_allocation_by_age, calculate_goal_based_savings, get_expense_optimization_tips,
+    format_currency, get_financial_milestones_by_age, calculate_retirement_corpus
+)
+
+# Custom CSS for MoneyMate branding
+CUSTOM_CSS = """
+.gradio-container {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    font-family: 'Inter', sans-serif;
+}
+
+.main-header {
+    text-align: center;
+    color: white;
+    margin-bottom: 2rem;
+}
+
+.money-card {
+    background: rgba(255, 255, 255, 0.95);
+    border-radius: 15px;
+    padding: 1.5rem;
+    margin: 1rem 0;
+    box-shadow: 0 8px 32px rgba(31, 38, 135, 0.37);
+    backdrop-filter: blur(4px);
+    border: 1px solid rgba(255, 255, 255, 0.18);
+}
+
+.modal-branding {
+    background: linear-gradient(45deg, #ff6b6b, #4ecdc4);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    font-weight: bold;
+    text-align: center;
+    margin-top: 1rem;
+}
+
+.advice-box {
+    background: #f8f9ff;
+    border-left: 4px solid #667eea;
+    padding: 1rem;
+    margin: 1rem 0;
+    border-radius: 8px;
+}
+
+.quick-action-btn {
+    background: linear-gradient(45deg, #667eea, #764ba2);
+    color: white;
+    border: none;
+    border-radius: 25px;
+    padding: 0.5rem 1rem;
+    margin: 0.25rem;
+    cursor: pointer;
+    transition: all 0.3s ease;
+}
+
+.quick-action-btn:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+}
+"""
+
+# Modal backend URL
+MODAL_BACKEND_URL = os.getenv("MODAL_BACKEND_URL", "https://kaustubhme0--moneymate-backend-fastapi-app.modal.run")
+
+def call_modal_financial_advice(user_input: str, context: Dict[str, Any] = None) -> str:
+    """Call Modal backend for AI-powered financial advice"""
+    try:
+        payload = {
+            "user_input": user_input,
+            "context": context or {}
+        }
+        
+        response = requests.post(
+            f"{MODAL_BACKEND_URL}/financial_advice",
+            json=payload,
+            timeout=60
+        )
+        
+        if response.status_code == 200:
+            return response.json().get("advice", "Unable to get advice at the moment.")
+        else:
+            return "Sorry, I'm having trouble connecting to the financial advisor. Please try again."
+            
+    except requests.exceptions.RequestException as e:
+        return f"Connection error: {str(e)}. Please check your internet connection."
+
+def call_modal_analyze_expenses(expenses: Dict[str, float], salary: float) -> Dict[str, Any]:
+    """Call Modal backend for expense analysis"""
+    try:
+        payload = {
+            "expenses": expenses,
+            "salary": salary
+        }
+        
+        response = requests.post(
+            f"{MODAL_BACKEND_URL}/analyze_expenses",
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            return response.json().get("analysis", {})
+        else:
+            # Fallback to local utils function
+            return {}
+            
+    except requests.exceptions.RequestException:
+        # Fallback to local utils function
+        return {}
+
+def call_modal_calculate_returns(monthly_investment: float, annual_return: float, years: int) -> Dict[str, Any]:
+    """Call Modal backend for investment return calculations"""
+    try:
+        payload = {
+            "monthly_investment": monthly_investment,
+            "annual_return_rate": annual_return,
+            "years": years
+        }
+        
+        response = requests.post(
+            f"{MODAL_BACKEND_URL}/calculate_returns",
+            json=payload,
+            timeout=30
+        )
+        
+        if response.status_code == 200:
+            return response.json().get("returns", {})
+        else:
+            # Fallback to local utils function
+            return calculate_sip_returns(monthly_investment, annual_return, years)
+            
+    except requests.exceptions.RequestException:
+        # Fallback to local utils function
+        return calculate_sip_returns(monthly_investment, annual_return, years)
+
+def check_modal_health() -> Dict[str, Any]:
+    """Check Modal backend health"""
+    try:
+        response = requests.get(f"{MODAL_BACKEND_URL}/health", timeout=10)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return {"status": "unhealthy", "message": "Backend not responding"}
+    except requests.exceptions.RequestException as e:
+        return {"status": "error", "message": str(e)}
+
+def create_salary_breakdown_chart(salary: float, needs: float, wants: float, savings: float):
+    """Create a pie chart for salary breakdown"""
+    labels = ['Needs (50%)', 'Wants (30%)', 'Savings (20%)']
+    values = [needs, wants, savings]
+    colors = ['#ff6b6b', '#4ecdc4', '#45b7d1']
+    
+    fig = go.Figure(data=[go.Pie(
+        labels=labels,
+        values=values,
+        hole=0.4,
+        marker_colors=colors,
+        textinfo='label+percent',
+        textfont_size=12
+    )])
+    
+    fig.update_layout(
+        title=f"Salary Breakdown for ₹{salary:,.0f}",
+        font=dict(size=14),
+        showlegend=True,
+        height=400
+    )
+    
+    return fig
+
+def create_expense_analysis_chart(expenses: Dict[str, float]):
+    """Create a bar chart for expense analysis"""
+    categories = list(expenses.keys())
+    amounts = list(expenses.values())
+    
+    fig = go.Figure([go.Bar(
+        x=categories,
+        y=amounts,
+        marker_color='#667eea',
+        text=[f"₹{amount:,.0f}" for amount in amounts],
+        textposition='auto'
+    )])
+    
+    fig.update_layout(
+        title="Monthly Expense Breakdown",
+        xaxis_title="Categories",
+        yaxis_title="Amount (₹)",
+        font=dict(size=12),
+        height=400
+    )
+    
+    return fig
+
+def create_investment_projection_chart(monthly_investment: float, years: int):
+    """Create investment projection chart using Modal backend"""
+    returns_data = call_modal_calculate_returns(monthly_investment, 12.0, years)
+    
+    if not returns_data:
+        return go.Figure()
+    
+    # Create year-wise projection
+    years_list = list(range(1, years + 1))
+    investment_values = []
+    
+    for year in years_list:
+        year_data = call_modal_calculate_returns(monthly_investment, 12.0, year)
+        investment_values.append(year_data.get('future_value', 0))
+    
+    fig = go.Figure()
+    
+    fig.add_trace(go.Scatter(
+        x=years_list,
+        y=investment_values,
+        mode='lines+markers',
+        name='Investment Growth',
+        line=dict(color='#667eea', width=3),
+        marker=dict(size=8)
+    ))
+    
+    fig.update_layout(
+        title=f"SIP Growth Projection (₹{monthly_investment:,.0f}/month @ 12% annual return)",
+        xaxis_title="Years",
+        yaxis_title="Amount (₹)",
+        font=dict(size=12),
+        height=400
+    )
+    
+    return fig
+
+def process_financial_query(
+    salary: float,
+    rent: float,
+    food: float,
+    transport: float,
+    utilities: float,
+    entertainment: float,
+    other: float,
+    savings_goal: str,
+    user_question: str
+) -> tuple:
+    """Process user's financial query with enhanced Modal integration"""
+    
+    # Validate inputs using utils
+    salary_valid, salary_msg = validate_salary(salary)
+    if not salary_valid:
+        return None, None, f"❌ {salary_msg}", "Please fix the salary amount and try again."
+    
+    # Calculate totals
+    total_expenses = rent + food + transport + utilities + entertainment + other
+    remaining_salary = salary - total_expenses
+    
+    # Create expense dictionary
+    expenses = {
+        "rent": rent,
+        "food": food,
+        "transport": transport,
+        "utilities": utilities,
+        "entertainment": entertainment,
+        "other": other
+    }
+    
+    # Validate expenses using utils
+    expenses_valid, expenses_msg, warnings = validate_expenses(expenses, salary)
+    if not expenses_valid:
+        return None, None, f"❌ {expenses_msg}", "Please adjust your expenses and try again."
+    
+    # Get salary breakdown using utils
+    breakdown = calculate_50_30_20_breakdown(salary)
+    needs = breakdown["needs"]
+    wants = breakdown["wants"]
+    savings = breakdown["savings"]
+    
+    # Get expense analysis from Modal backend
+    modal_analysis = call_modal_analyze_expenses(expenses, salary)
+    
+    # Get optimization tips from utils
+    optimization_tips = get_expense_optimization_tips(expenses, salary)
+    
+    # Create charts
+    salary_chart = create_salary_breakdown_chart(salary, needs, wants, savings)
+    expense_chart = create_expense_analysis_chart({k.title(): v for k, v in expenses.items()})
+    
+    # Calculate emergency fund target using utils
+    emergency_fund = calculate_emergency_fund_target(total_expenses)
+    
+    # Prepare context for Modal backend
+    context = {
+        "salary": salary,
+        "expenses": expenses,
+        "total_expenses": total_expenses,
+        "remaining_salary": remaining_salary,
+        "savings_goal": savings_goal,
+        "breakdown": breakdown,
+        "emergency_fund": emergency_fund,
+        "optimization_tips": optimization_tips[:3]  # Top 3 tips
+    }
+    
+    # Get AI advice from Modal
+    if user_question.strip():
+        advice = call_modal_financial_advice(user_question, context)
+    else:
+        advice = call_modal_financial_advice(f"Analyze my finances: Salary ₹{salary}, Total expenses ₹{total_expenses}", context)
+    
+    # Create enhanced summary
+    summary = f"""
+    ## 💰 Financial Summary
+    
+    **Monthly Salary:** ₹{salary:,.0f}
+    **Total Expenses:** ₹{total_expenses:,.0f}
+    **Remaining Amount:** ₹{remaining_salary:,.0f}
+    
+    ### 📊 Recommended Allocation (50/30/20 Rule)
+    - **Needs (50%):** ₹{needs:,.0f}
+    - **Wants (30%):** ₹{wants:,.0f}  
+    - **Savings (20%):** ₹{savings:,.0f}
+    
+    ### 🎯 Status
+    {'✅ Good job! You have money left over.' if remaining_salary > 0 else '⚠️ You are overspending. Consider reducing expenses.'}
+    
+    ### 🚨 Emergency Fund Target
+    **Target Amount:** ₹{emergency_fund['target_amount']:,.0f} ({emergency_fund['months_coverage']} months)
+    
+    ### 💡 Quick Optimization Tips
+    {chr(10).join(f"• {tip}" for tip in optimization_tips[:3])}
+    
+    ### ⚠️ Warnings
+    {chr(10).join(f"• {warning}" for warning in warnings) if warnings else "No warnings - you're doing great!"}
+    """
+    
+    return salary_chart, expense_chart, summary, advice
+
+def calculate_sip_projection(monthly_investment: float, annual_return: float, years: int) -> tuple:
+    """Calculate and visualize SIP projections using Modal backend"""
+    
+    if monthly_investment <= 0 or years <= 0:
+        return None, "Please enter valid investment amount and timeline."
+    
+    # Get returns data from Modal backend
+    returns_data = call_modal_calculate_returns(monthly_investment, annual_return, years)
+    
+    if not returns_data:
+        return None, "Unable to calculate returns. Please try again."
+    
+    # Create projection chart
+    projection_chart = create_investment_projection_chart(monthly_investment, years)
+    
+    # Create summary
+    summary = f"""
+    ## 📈 SIP Investment Projection
+    
+    **Monthly Investment:** ₹{monthly_investment:,.0f}
+    **Annual Return:** {annual_return}%
+    **Investment Period:** {years} years
+    
+    ### 💰 Projected Results
+    - **Total Invested:** ₹{returns_data.get('total_invested', 0):,.0f}
+    - **Future Value:** ₹{returns_data.get('future_value', 0):,.0f}
+    - **Returns Generated:** ₹{returns_data.get('returns', 0):,.0f}
+    - **Return Percentage:** {returns_data.get('return_percentage', 0):.1f}%
+    
+    ### 🎯 Wealth Creation
+    Your ₹{monthly_investment:,.0f} monthly investment will grow to ₹{returns_data.get('future_value', 0):,.0f} in {years} years!
+    """
+    
+    return projection_chart, summary
+
+def handle_quick_question(question: str, salary: float = 50000) -> str:
+    """Handle pre-defined quick questions"""
+    context = {"salary": salary}
+    return call_modal_financial_advice(question, context)
+
+def show_health_status() -> str:
+    """Show Modal backend health status"""
+    health = check_modal_health()
+    
+    if health.get("status") == "healthy":
+        return "✅ Backend is healthy and running!"
+    else:
+        return f"❌ Backend issue: {health.get('message', 'Unknown error')}"
+
+# Create Gradio interface
+def create_moneymate_app():
+    with gr.Blocks(css=CUSTOM_CSS, title="MoneyMate - Your Financial Assistant") as app:
+        
+        # Header
+        gr.HTML("""
+            <div class="main-header">
+                <h1>💰 MoneyMate</h1>
+                <p>Your Personal Financial Assistant for Smart Money Management</p>
+                <div class="modal-branding">⚡ Powered by Modal Labs</div>
+            </div>
+        """)
+        
+        with gr.Tabs():
+            # Main Financial Analysis Tab
+            with gr.Tab("💼 Financial Analysis"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.HTML('<div class="money-card">')
+                        gr.Markdown("### 💼 Your Financial Details")
+                        
+                        salary_input = gr.Number(
+                            label="Monthly Salary (₹)",
+                            value=50000,
+                            minimum=0,
+                            step=1000
+                        )
+                        
+                        gr.Markdown("#### Monthly Expenses")
+                        rent_input = gr.Number(label="Rent (₹)", value=15000, minimum=0)
+                        food_input = gr.Number(label="Food (₹)", value=8000, minimum=0)
+                        transport_input = gr.Number(label="Transport (₹)", value=3000, minimum=0)
+                        utilities_input = gr.Number(label="Utilities (₹)", value=2000, minimum=0)
+                        entertainment_input = gr.Number(label="Entertainment (₹)", value=4000, minimum=0)
+                        other_input = gr.Number(label="Other Expenses (₹)", value=3000, minimum=0)
+                        
+                        savings_goal_input = gr.Textbox(
+                            label="Savings Goal",
+                            placeholder="e.g., Emergency fund, Vacation, House down payment",
+                            value="Emergency fund"
+                        )
+                        
+                        user_question_input = gr.Textbox(
+                            label="Ask MoneyMate",
+                            placeholder="e.g., How should I invest my savings? What's the best way to save for a house?",
+                            lines=3
+                        )
+                        
+                        analyze_btn = gr.Button("Analyze My Finances 📊", variant="primary", size="large")
+                        health_btn = gr.Button("Check Backend Status 🔍", variant="secondary", size="small")
+                        health_status = gr.Textbox(label="Status", interactive=False)
+                        
+                        gr.HTML('</div>')
+                        
+                        # Quick action buttons
+                        gr.HTML('<div class="money-card">')
+                        gr.Markdown("### 🚀 Quick Questions")
+                        
+                        with gr.Row():
+                            quick_btn1 = gr.Button("💡 Investment Tips", size="small")
+                            quick_btn2 = gr.Button("🏠 Save for House", size="small")
+                        
+                        with gr.Row():
+                            quick_btn3 = gr.Button("✈️ Plan Vacation", size="small")
+                            quick_btn4 = gr.Button("🚗 Buy a Car", size="small")
+                        
+                        gr.HTML('</div>')
+                    
+                    with gr.Column(scale=2):
+                        gr.HTML('<div class="money-card">')
+                        
+                        # Output components
+                        with gr.Tab("📊 Salary Breakdown"):
+                            salary_chart_output = gr.Plot()
+                        
+                        with gr.Tab("💸 Expense Analysis"):
+                            expense_chart_output = gr.Plot()
+                        
+                        with gr.Tab("📋 Summary"):
+                            summary_output = gr.Markdown()
+                        
+                        with gr.Tab("🤖 AI Advice"):
+                            advice_output = gr.Markdown(value="Click 'Analyze My Finances' to get personalized advice!")
+                        
+                        gr.HTML('</div>')
+            
+            # SIP Calculator Tab
+            with gr.Tab("📈 SIP Calculator"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📈 SIP Investment Calculator")
+                        
+                        monthly_investment_input = gr.Number(
+                            label="Monthly Investment (₹)",
+                            value=5000,
+                            minimum=500,
+                            step=500
+                        )
+                        
+                        annual_return_input = gr.Number(
+                            label="Expected Annual Return (%)",
+                            value=12.0,
+                            minimum=1.0,
+                            maximum=30.0,
+                            step=0.5
+                        )
+                        
+                        years_input = gr.Number(
+                            label="Investment Period (Years)",
+                            value=10,
+                            minimum=1,
+                            maximum=50,
+                            step=1
+                        )
+                        
+                        calculate_sip_btn = gr.Button("Calculate SIP Returns 📊", variant="primary")
+                        
+                    with gr.Column(scale=2):
+                        sip_chart_output = gr.Plot()
+                        sip_summary_output = gr.Markdown()
+        
+        # Event handlers
+        analyze_btn.click(
+            fn=process_financial_query,
+            inputs=[
+                salary_input, rent_input, food_input, transport_input,
+                utilities_input, entertainment_input, other_input,
+                savings_goal_input, user_question_input
+            ],
+            outputs=[salary_chart_output, expense_chart_output, summary_output, advice_output]
+        )
+        
+        calculate_sip_btn.click(
+            fn=calculate_sip_projection,
+            inputs=[monthly_investment_input, annual_return_input, years_input],
+            outputs=[sip_chart_output, sip_summary_output]
+        )
+        
+        health_btn.click(
+            fn=show_health_status,
+            outputs=[health_status]
+        )
+        
+        # Quick question handlers
+        quick_btn1.click(
+            fn=lambda s: handle_quick_question("What are the best investment options for a beginner in India?", s),
+            inputs=[salary_input],
+            outputs=[advice_output]  
+        )
+        
+        quick_btn2.click(
+            fn=lambda s: handle_quick_question("How should I save for buying a house in India?", s),
+            inputs=[salary_input],
+            outputs=[advice_output]
+        )
+        
+        quick_btn3.click(
+            fn=lambda s: handle_quick_question("What's the best way to save for a vacation?", s),
+            inputs=[salary_input],
+            outputs=[advice_output]
+        )
+        
+        quick_btn4.click(
+            fn=lambda s: handle_quick_question("How should I plan to buy a car with my salary?", s),
+            inputs=[salary_input], 
+            outputs=[advice_output]
+        )
+        
+        # Footer
+        gr.HTML("""
+            <div style="text-align: center; margin-top: 2rem; color: white;">
+                <p>Made with ❤️ for Agents & MCP Hackathon 2025</p>
+                <p>🏆 Track 1 — MCP Tool / Server</p>
+            </div>
+        """)
+    
+    return app
+
+if __name__ == "__main__":
+    app = create_moneymate_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
     )