Uploading necessary files to the Space (#1)

- Uploading necessary files to the Space (74e4c794807ed6165a70921c2f1bf681b70a2ca2)

app.py

@@ -0,0 +1,523 @@
+
+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
+
+# 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);
+}
+"""
+
+# MCP Server configuration
+class MCPServer:
+    def __init__(self):
+        self.tools = {
+            "salary_breakdown": self.salary_breakdown,
+            "investment_advice": self.investment_advice,
+            "expense_analysis": self.expense_analysis,
+            "savings_goal": self.savings_goal
+        }
+    
+    def salary_breakdown(self, salary: float, expenses: Dict[str, float]) -> Dict[str, Any]:
+        """Break down salary using 50/30/20 rule with Indian context"""
+        needs = salary * 0.5  # 50% for needs
+        wants = salary * 0.3  # 30% for wants
+        savings = salary * 0.2  # 20% for savings/investments
+        
+        return {
+            "breakdown": {
+                "needs": needs,
+                "wants": wants,
+                "savings": savings
+            },
+            "recommendations": self._get_indian_recommendations(salary)
+        }
+    
+    def investment_advice(self, age: int, salary: float, risk_appetite: str) -> Dict[str, Any]:
+        """Provide investment advice for Indian market"""
+        equity_percentage = min(100 - age, 80)  # Age-based equity allocation
+        debt_percentage = 100 - equity_percentage
+        
+        return {
+            "allocation": {
+                "equity": equity_percentage,
+                "debt": debt_percentage
+            },
+            "instruments": self._get_indian_instruments(risk_appetite)
+        }
+    
+    def expense_analysis(self, expenses: Dict[str, float]) -> Dict[str, Any]:
+        """Analyze expenses and provide optimization suggestions"""
+        total_expenses = sum(expenses.values())
+        analysis = {}
+        
+        for category, amount in expenses.items():
+            percentage = (amount / total_expenses) * 100
+            analysis[category] = {
+                "amount": amount,
+                "percentage": percentage,
+                "status": self._categorize_expense(category, percentage)
+            }
+        
+        return {"analysis": analysis, "suggestions": self._get_optimization_tips()}
+    
+    def savings_goal(self, goal_amount: float, timeline_months: int, current_savings: float) -> Dict[str, Any]:
+        """Calculate monthly savings needed for a goal"""
+        remaining_amount = goal_amount - current_savings
+        monthly_required = remaining_amount / timeline_months if timeline_months > 0 else 0
+        
+        return {
+            "monthly_required": monthly_required,
+            "total_goal": goal_amount,
+            "timeline": timeline_months,
+            "feasibility": "achievable" if monthly_required < 15000 else "challenging"
+        }
+    
+    def _get_indian_recommendations(self, salary: float) -> list:
+        """Get India-specific financial recommendations"""
+        recommendations = [
+            "Build emergency fund of 6-12 months expenses",
+            "Start SIP in diversified equity mutual funds",
+            "Consider ELSS funds for tax saving under 80C",
+            "Open PPF account for long-term tax-free returns"
+        ]
+        
+        if salary > 50000:
+            recommendations.append("Consider NPS for additional retirement planning")
+        if salary > 100000:
+            recommendations.append("Explore direct equity investment after gaining knowledge")
+            
+        return recommendations
+    
+    def _get_indian_instruments(self, risk_appetite: str) -> list:
+        """Get Indian investment instruments based on risk appetite"""
+        instruments = {
+            "conservative": ["PPF", "NSC", "FD", "Debt Mutual Funds"],
+            "moderate": ["Balanced Mutual Funds", "ELSS", "Gold ETF", "Corporate Bonds"],
+            "aggressive": ["Large Cap Funds", "Mid Cap Funds", "Small Cap Funds", "Direct Equity"]
+        }
+        return instruments.get(risk_appetite.lower(), instruments["moderate"])
+    
+    def _categorize_expense(self, category: str, percentage: float) -> str:
+        """Categorize expense as optimal, high, or low"""
+        thresholds = {
+            "rent": (25, 35),
+            "food": (15, 25),
+            "transport": (10, 15),
+            "utilities": (5, 10),
+            "entertainment": (5, 15)
+        }
+        
+        if category.lower() in thresholds:
+            low, high = thresholds[category.lower()]
+            if percentage < low:
+                return "low"
+            elif percentage > high:
+                return "high"
+        return "optimal"
+    
+    def _get_optimization_tips(self) -> list:
+        """Get expense optimization tips"""
+        return [
+            "Use public transport or carpool to reduce transport costs",
+            "Cook at home more often to save on food expenses",
+            "Use energy-efficient appliances to reduce utility bills",
+            "Set a monthly entertainment budget and stick to it",
+            "Review and cancel unused subscriptions"
+        ]
+
+# Initialize MCP Server
+mcp_server = MCPServer()
+
+# Modal backend URL (replace with your actual Modal deployment URL)
+MODAL_BACKEND_URL = os.getenv("MODAL_BACKEND_URL", "https://kaustubhme0--moneymate-backend-fastapi-app.modal.run")
+
+def call_modal_backend(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=30
+        )
+        
+        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 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 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 and return advice with visualizations"""
+    
+    # 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
+    }
+    
+    # Get salary breakdown using 50/30/20 rule
+    breakdown = mcp_server.salary_breakdown(salary, expenses)
+    needs = breakdown["breakdown"]["needs"]
+    wants = breakdown["breakdown"]["wants"]
+    savings = breakdown["breakdown"]["savings"]
+    
+    # Create charts
+    salary_chart = create_salary_breakdown_chart(salary, needs, wants, savings)
+    expense_chart = create_expense_analysis_chart(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
+    }
+    
+    # Get AI advice
+    if user_question.strip():
+        advice = call_modal_backend(user_question, context)
+    else:
+        advice = call_modal_backend(f"Analyze my finances: Salary ₹{salary}, Total expenses ₹{total_expenses}", context)
+    
+    # Create 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.'}
+    """
+    
+    return salary_chart, expense_chart, summary, advice
+
+def handle_quick_question(question: str, salary: float = 50000) -> str:
+    """Handle pre-defined quick questions"""
+    context = {"salary": salary}
+    return call_modal_backend(question, context)
+
+# 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.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")
+                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>')
+        
+        # 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]
+        )
+        
+        # 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
+
+# FastAPI wrapper for MCP compatibility
+app_fastapi = FastAPI()
+
+# Create and mount Gradio app
+gradio_app = create_moneymate_app()
+
+# MCP endpoints
+@app_fastapi.post("/mcp/tools")
+async def list_tools():
+    """List available MCP tools"""
+    return {
+        "tools": [
+            {
+                "name": "salary_breakdown",
+                "description": "Break down salary using 50/30/20 rule",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "salary": {"type": "number"},
+                        "expenses": {"type": "object"}
+                    }
+                }
+            },
+            {
+                "name": "investment_advice", 
+                "description": "Get investment advice for Indian market",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "age": {"type": "integer"},
+                        "salary": {"type": "number"},
+                        "risk_appetite": {"type": "string"}
+                    }
+                }
+            }
+        ]
+    }
+
+@app_fastapi.post("/mcp/call_tool")
+async def call_tool(request: dict):
+    """Call MCP tool"""
+    tool_name = request.get("name")
+    arguments = request.get("arguments", {})
+    
+    if tool_name in mcp_server.tools:
+        result = mcp_server.tools[tool_name](**arguments)
+        return {"content": [{"type": "text", "text": json.dumps(result, indent=2)}]}
+    else:
+        return {"error": f"Tool {tool_name} not found"}
+
+# Mount Gradio app
+gr.mount_gradio_app(app_fastapi, gradio_app, path="/")
+
+if __name__ == "__main__":
+    gradio_app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

demo_inputs.json

@@ -0,0 +1,246 @@
+{
+    "mcp_server_info": {
+      "name": "MoneyMate",
+      "version": "1.0.0",
+      "description": "AI-powered financial assistant for young Indian professionals",
+      "server_url": "https://kaustubhme0--moneymate-backend-fastapi-app.modal.run",
+      "gradio_app_url": "https://huggingface.co/spaces/[YOUR_USERNAME]/moneymate",
+      "mcp_compatibility": true
+    },
+    "sample_queries": [
+      {
+        "id": "salary_breakdown",
+        "category": "Salary Planning",
+        "user_input": "I earn ₹75,000 per month. How should I allocate my salary?",
+        "context": {
+          "salary": 75000,
+          "expenses": {
+            "rent": 25000,
+            "food": 8000,
+            "transport": 5000,
+            "utilities": 3000,
+            "entertainment": 7000
+          },
+          "total_expenses": 48000,
+          "remaining_salary": 27000,
+          "savings_goal": "Emergency fund and investments"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "Basic salary allocation using 50/30/20 rule"
+      },
+      {
+        "id": "first_job_planning",
+        "category": "Career Starter",
+        "user_input": "I just got my first job at ₹45,000. What should I do with my money?",
+        "context": {
+          "salary": 45000,
+          "expenses": {
+            "rent": 15000,
+            "food": 6000,
+            "transport": 3000,
+            "utilities": 2000,
+            "personal": 3000
+          },
+          "total_expenses": 29000,
+          "remaining_salary": 16000,
+          "savings_goal": "Build foundation for financial future"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "First job financial planning guidance"
+      },
+      {
+        "id": "investment_planning",
+        "category": "Investment Advice",
+        "user_input": "I have ₹20,000 left after expenses. How should I invest this money?",
+        "context": {
+          "salary": 60000,
+          "expenses": {
+            "rent": 20000,
+            "food": 7000,
+            "transport": 4000,
+            "utilities": 2500,
+            "entertainment": 6500
+          },
+          "total_expenses": 40000,
+          "remaining_salary": 20000,
+          "savings_goal": "Long-term wealth building"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "Investment strategy for surplus income"
+      },
+      {
+        "id": "emergency_fund",
+        "category": "Emergency Planning",
+        "user_input": "How much should I keep as emergency fund and where should I keep it?",
+        "context": {
+          "salary": 80000,
+          "expenses": {
+            "rent": 30000,
+            "food": 10000,
+            "transport": 6000,
+            "utilities": 4000,
+            "entertainment": 8000,
+            "miscellaneous": 5000
+          },
+          "total_expenses": 63000,
+          "remaining_salary": 17000,
+          "savings_goal": "Build emergency fund"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "Emergency fund planning and placement"
+      },
+      {
+        "id": "goal_based_saving",
+        "category": "Goal Planning",
+        "user_input": "I want to buy a car worth ₹8 lakhs in 2 years. How much should I save monthly?",
+        "context": {
+          "salary": 90000,
+          "expenses": {
+            "rent": 25000,
+            "food": 12000,
+            "transport": 8000,
+            "utilities": 4000,
+            "entertainment": 10000,
+            "miscellaneous": 6000
+          },
+          "total_expenses": 65000,
+          "remaining_salary": 25000,
+          "savings_goal": "Car purchase in 2 years - ₹8 lakhs"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "Goal-based savings calculation"
+      },
+      {
+        "id": "tax_planning",
+        "category": "Tax Optimization",
+        "user_input": "I need to save tax under Section 80C. What are my best options?",
+        "context": {
+          "salary": 120000,
+          "expenses": {
+            "rent": 35000,
+            "food": 15000,
+            "transport": 8000,
+            "utilities": 5000,
+            "entertainment": 12000,
+            "miscellaneous": 8000
+          },
+          "total_expenses": 83000,
+          "remaining_salary": 37000,
+          "savings_goal": "Tax saving and wealth building"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "Tax saving strategies under Section 80C"
+      },
+      {
+        "id": "expense_optimization",
+        "category": "Expense Management",
+        "user_input": "My expenses are too high. How can I reduce them without affecting my lifestyle?",
+        "context": {
+          "salary": 70000,
+          "expenses": {
+            "rent": 28000,
+            "food": 12000,
+            "transport": 8000,
+            "utilities": 4000,
+            "entertainment": 15000,
+            "shopping": 8000,
+            "miscellaneous": 5000
+          },
+          "total_expenses": 80000,
+          "remaining_salary": -10000,
+          "savings_goal": "Reduce expenses and start saving"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "Expense optimization without lifestyle compromise"
+      },
+      {
+        "id": "retirement_planning",
+        "category": "Long-term Planning",
+        "user_input": "I'm 25 years old. When should I start planning for retirement?",
+        "context": {
+          "salary": 65000,
+          "expenses": {
+            "rent": 22000,
+            "food": 8000,
+            "transport": 5000,
+            "utilities": 3000,
+            "entertainment": 8000,
+            "miscellaneous": 4000
+          },
+          "total_expenses": 50000,
+          "remaining_salary": 15000,
+          "savings_goal": "Early retirement planning"
+        },
+        "expected_response_type": "financial_advice",
+        "description": "Early career retirement planning"
+      }
+    ],
+    "mcp_integration_examples": [
+      {
+        "client": "Cursor IDE",
+        "query": "Help me plan my ₹80,000 salary allocation",
+        "mcp_request": {
+          "method": "POST",
+          "endpoint": "/financial_advice",
+          "payload": {
+            "user_input": "Help me plan my ₹80,000 salary allocation",
+            "context": {
+              "salary": 80000,
+              "expenses": {},
+              "savings_goal": "General financial planning"
+            }
+          }
+        }
+      },
+      {
+        "client": "Claude Desktop",
+        "query": "Calculate SIP returns for ₹10,000 monthly investment",
+        "mcp_request": {
+          "method": "POST",
+          "endpoint": "/calculate_returns",
+          "payload": {
+            "monthly_investment": 10000,
+            "annual_return_rate": 12,
+            "years": 10
+          }
+        }
+      }
+    ],
+    "gradio_interface_examples": [
+      {
+        "salary_input": 75000,
+        "expenses_input": "rent 25000, food 8000, transport 5000, utilities 3000, entertainment 7000",
+        "question_input": "How should I allocate my remaining ₹27,000?",
+        "expected_output": "Markdown formatted advice with pie chart showing allocation"
+      },
+      {
+        "salary_input": 45000,
+        "expenses_input": "rent 15000, food 6000, transport 3000, utilities 2000, personal 3000",
+        "question_input": "What's the best way to start investing?",
+        "expected_output": "Beginner-friendly investment advice with risk assessment"
+      }
+    ],
+    "testing_scenarios": [
+      {
+        "name": "High Expenses",
+        "salary": 50000,
+        "expenses": "rent 30000, food 10000, transport 5000, entertainment 8000",
+        "question": "My expenses exceed my salary. What should I do?",
+        "expected_behavior": "Expense optimization advice and practical solutions"
+      },
+      {
+        "name": "High Earner",
+        "salary": 200000,
+        "expenses": "rent 40000, food 15000, transport 10000, utilities 5000, entertainment 20000",
+        "question": "How should I invest my surplus income?",
+        "expected_behavior": "Advanced investment strategies and tax planning"
+      },
+      {
+        "name": "Conservative Investor",
+        "salary": 60000,
+        "expenses": "rent 20000, food 8000, transport 4000, utilities 3000, entertainment 5000",
+        "question": "I'm afraid of stock market risks. What are safe investment options?",
+        "expected_behavior": "Conservative investment options with risk explanation"
+      }
+    ]
+  }

modal_app.py

@@ -0,0 +1,412 @@
+import modal
+import json
+from typing import Dict, Any, Optional
+from datetime import datetime
+import os
+import urllib.request
+import urllib.parse
+
+# Create Modal app
+app = modal.App("moneymate-backend")
+
+# Create image with required dependencies
+image = modal.Image.debian_slim(python_version="3.11").pip_install([
+    "fastapi",
+    "pydantic"
+])
+
+# vLLM server configuration
+# TODO: Replace with your actual vLLM server URL after deployment
+VLLM_SERVER_URL = "https://kaustubhme0--example-vllm-openai-compatible-serve.modal.run"
+
+# This API key should match the API_KEY in your vLLM inference script (paste.txt)
+# It's YOUR custom key, not from any external service
+VLLM_API_KEY = "super-secret-key"
+
+# Financial advisor system prompt
+SYSTEM_PROMPT = """You are MoneyMate, a friendly and knowledgeable financial advisor specifically designed for young Indian professionals who are new to managing their salaries and finances.
+
+PERSONALITY & TONE:
+- Warm, approachable, and encouraging
+- Use simple, jargon-free language
+- Be supportive and non-judgmental
+- Add appropriate emojis to make advice engaging
+- Safety-first approach - always emphasize careful consideration
+
+EXPERTISE AREAS:
+- Salary allocation and budgeting
+- Indian investment options (SIP, ELSS, PPF, NPS, etc.)
+- Tax-saving strategies under Indian tax law
+- Emergency fund planning
+- Goal-based financial planning
+- Expense optimization
+
+RESPONSE FORMAT:
+- Use markdown formatting for better readability
+- Include practical examples with Indian Rupee amounts
+- Provide step-by-step actionable advice
+- Always include safety disclaimers for investment advice
+- Suggest starting small and learning gradually
+
+CULTURAL CONTEXT:
+- Understand Indian financial instruments and regulations
+- Consider family financial responsibilities common in India
+- Be aware of Indian tax implications (80C, LTCG, etc.)
+- Reference Indian banks, mutual fund companies, and financial platforms
+
+SAFETY GUIDELINES:
+- Never guarantee returns or specific outcomes
+- Always recommend consulting financial advisors for major decisions
+- Emphasize the importance of emergency funds before investing
+- Warn about risks associated with investments
+- Promote financial literacy and gradual learning
+
+Remember: You're helping someone who may be handling their first salary. Be patient, educational, and encouraging while prioritizing their financial safety and security.
+"""
+
+def call_vllm_api(messages: list, max_tokens: int = 1500, temperature: float = 0.7) -> str:
+    """Call the vLLM server with OpenAI-compatible API"""
+    
+    headers = {
+        "Authorization": f"Bearer {VLLM_API_KEY}",
+        "Content-Type": "application/json",
+    }
+    
+    payload = {
+        "messages": messages,
+        "model": "neuralmagic/Meta-Llama-3.1-8B-Instruct-quantized.w4a16",
+        "max_tokens": max_tokens,
+        "temperature": temperature
+    }
+    
+    try:
+        req = urllib.request.Request(
+            f"{VLLM_SERVER_URL}/v1/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers=headers,
+            method="POST",
+        )
+        
+        # Increased timeout to 180 seconds (3 minutes) for LLM responses
+        with urllib.request.urlopen(req, timeout=180) as response:
+            if response.getcode() == 200:
+                result = json.loads(response.read().decode())
+                return result["choices"][0]["message"]["content"]
+            else:
+                response_text = response.read().decode()
+                raise Exception(f"API call failed with status {response.getcode()}: {response_text}")
+                
+    except urllib.error.URLError as e:
+        if "timeout" in str(e).lower():
+            raise Exception("Request timed out. The vLLM server might be taking too long to respond or might be cold starting.")
+        else:
+            raise Exception(f"Network error calling vLLM API: {str(e)}")
+    except Exception as e:
+        raise Exception(f"Error calling vLLM API: {str(e)}")
+
+@app.function(
+    image=image,
+    timeout=300,  # Increased to 5 minutes
+    memory=1024
+)
+def get_financial_advice(user_input: str, context: Dict[str, Any] = None) -> str:
+    """Generate financial advice using local vLLM server"""
+    
+    try:
+        # Prepare context information
+        context_str = ""
+        if context:
+            salary = context.get("salary", 0)
+            expenses = context.get("expenses", {})
+            total_expenses = context.get("total_expenses", 0)
+            remaining_salary = context.get("remaining_salary", 0)
+            savings_goal = context.get("savings_goal", "")
+            
+            context_str = f"""
+            CURRENT FINANCIAL SITUATION:
+            - Monthly Salary: ₹{salary:,.0f}
+            - Total Monthly Expenses: ₹{total_expenses:,.0f}
+            - Remaining Amount: ₹{remaining_salary:,.0f}
+            - Savings Goal: {savings_goal}
+            
+            EXPENSE BREAKDOWN:
+            """
+            
+            for category, amount in expenses.items():
+                if amount > 0:
+                    context_str += f"- {category}: ₹{amount:,.0f}\n"
+        
+        # Create the full prompt
+        user_prompt = f"""
+        {context_str}
+        
+        USER QUESTION: {user_input}
+        
+        Please provide personalized financial advice based on this information. Focus on:
+        1. Specific recommendations for their situation
+        2. Practical next steps they can take
+        3. Indian financial instruments and strategies
+        4. Risk management and safety
+        5. Educational insights to help them learn
+        """
+        
+        # Prepare messages for vLLM
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": user_prompt}
+        ]
+        
+        # Call vLLM API
+        advice = call_vllm_api(messages, max_tokens=1500, temperature=0.7)
+        
+        # Add timestamp and additional context
+        current_time = datetime.now().strftime("%B %d, %Y at %I:%M %p")
+        
+        formatted_advice = f"""
+{advice}
+
+---
+
+💡 **MoneyMate Tips:**
+- Start small and gradually increase your investments
+- Always maintain 6-12 months of expenses as emergency fund
+- Review and adjust your financial plan quarterly
+- Consider consulting a certified financial planner for major decisions
+
+*Advice generated on {current_time}*
+        """
+        
+        return formatted_advice.strip()
+        
+    except Exception as e:
+        error_msg = f"""
+## 😔 Sorry, I'm having trouble right now
+
+I encountered an error while processing your request: {str(e)}
+
+**Here are some general tips while I'm unavailable:**
+
+### 💰 Basic Financial Rules for Young Professionals:
+- **50/30/20 Rule**: Allocate 50% for needs, 30% for wants, 20% for savings
+- **Emergency Fund**: Build 6-12 months of expenses before investing
+- **Start Small**: Begin with SIP of ₹1000-2000 monthly in diversified funds
+- **Tax Planning**: Use ELSS funds to save tax under Section 80C
+
+### 🏦 Safe Investment Options for Beginners:
+- **SIP in Index Funds**: Low cost, diversified exposure
+- **PPF**: 15-year lock-in, tax-free returns
+- **ELSS Funds**: Tax saving with 3-year lock-in
+- **Liquid Funds**: For emergency fund parking
+
+Please try again in a few moments, or check your connection to the vLLM server.
+        """
+        
+        return error_msg
+
+@app.function(
+    image=image,
+    timeout=30
+)
+def analyze_expenses(expenses: Dict[str, float], salary: float) -> Dict[str, Any]:
+    """Analyze expense patterns and provide optimization suggestions"""
+    
+    total_expenses = sum(expenses.values())
+    expense_ratio = (total_expenses / salary) * 100 if salary > 0 else 0
+    
+    analysis = {
+        "total_expenses": total_expenses,
+        "expense_ratio": expense_ratio,
+        "status": "healthy" if expense_ratio < 70 else "concerning",
+        "recommendations": []
+    }
+    
+    # Analyze each category
+    for category, amount in expenses.items():
+        category_ratio = (amount / salary) * 100 if salary > 0 else 0
+        
+        # Category-specific recommendations
+        if category.lower() == "rent" and category_ratio > 40:
+            analysis["recommendations"].append(f"🏠 Rent is high ({category_ratio:.1f}% of salary). Consider relocating or finding roommates.")
+        elif category.lower() == "food" and category_ratio > 20:
+            analysis["recommendations"].append(f"🍽️ Food expenses are high ({category_ratio:.1f}% of salary). Try cooking at home more often.")
+        elif category.lower() == "entertainment" and category_ratio > 15:
+            analysis["recommendations"].append(f"🎬 Entertainment expenses are high ({category_ratio:.1f}% of salary). Set a monthly budget and stick to it.")
+    
+    return analysis
+
+@app.function(
+    image=image,
+    timeout=30
+)
+def calculate_investment_returns(
+    monthly_investment: float,
+    annual_return_rate: float,
+    years: int
+) -> Dict[str, Any]:
+    """Calculate SIP returns with compound interest"""
+    
+    monthly_rate = annual_return_rate / 12 / 100
+    total_months = years * 12
+    
+    # SIP future value formula
+    if monthly_rate > 0:
+        future_value = monthly_investment * (((1 + monthly_rate) ** total_months - 1) / monthly_rate) * (1 + monthly_rate)
+    else:
+        future_value = monthly_investment * total_months
+    
+    total_invested = monthly_investment * total_months
+    returns = future_value - total_invested
+    
+    return {
+        "future_value": round(future_value, 2),
+        "total_invested": round(total_invested, 2),
+        "returns": round(returns, 2),
+        "return_percentage": round((returns / total_invested) * 100, 2) if total_invested > 0 else 0
+    }
+
+@app.function(
+    image=image,
+    timeout=60
+)
+def health_check_vllm() -> Dict[str, Any]:
+    """Check if vLLM server is healthy"""
+    try:
+        with urllib.request.urlopen(f"{VLLM_SERVER_URL}/health", timeout=30) as response:
+            if response.getcode() == 200:
+                return {"vllm_status": "healthy", "server_url": VLLM_SERVER_URL}
+            else:
+                return {"vllm_status": "unhealthy", "server_url": VLLM_SERVER_URL, "status_code": response.getcode()}
+    except Exception as e:
+        return {"vllm_status": "error", "error": str(e), "server_url": VLLM_SERVER_URL}
+
+# FastAPI app for HTTP endpoints
+@app.function(image=image)
+@modal.asgi_app()
+def fastapi_app():
+    from fastapi import FastAPI, HTTPException
+    from pydantic import BaseModel
+    from typing import Optional
+    
+    api = FastAPI(title="MoneyMate Backend API with vLLM")
+    
+    class FinancialAdviceRequest(BaseModel):
+        user_input: str
+        context: Optional[Dict[str, Any]] = None
+    
+    class ExpenseAnalysisRequest(BaseModel):
+        expenses: Dict[str, float]
+        salary: float
+    
+    class InvestmentCalculationRequest(BaseModel):
+        monthly_investment: float
+        annual_return_rate: float
+        years: int
+    
+    @api.post("/financial_advice")
+    async def get_advice(request: FinancialAdviceRequest):
+        """Get AI-powered financial advice using vLLM"""
+        try:
+            advice = get_financial_advice.remote(request.user_input, request.context)
+            return {"advice": advice}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @api.post("/analyze_expenses")
+    async def analyze_user_expenses(request: ExpenseAnalysisRequest):
+        """Analyze user's expense patterns"""
+        try:
+            analysis = analyze_expenses.remote(request.expenses, request.salary)
+            return {"analysis": analysis}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @api.post("/calculate_returns")
+    async def calculate_returns(request: InvestmentCalculationRequest):
+        """Calculate SIP investment returns"""
+        try:
+            returns = calculate_investment_returns.remote(
+                request.monthly_investment,
+                request.annual_return_rate,
+                request.years
+            )
+            return {"returns": returns}
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+    
+    @api.get("/health")
+    async def health_check():
+        """Health check endpoint including vLLM server status"""
+        vllm_health = health_check_vllm.remote()
+        return {
+            "status": "healthy", 
+            "service": "MoneyMate Backend with vLLM",
+            "vllm_server": vllm_health
+        }
+    
+    @api.get("/")
+    async def root():
+        """Root endpoint with service information"""
+        return {
+            "service": "MoneyMate Backend API with vLLM",
+            "version": "2.0.0",
+            "description": "AI-powered financial advice for young Indian professionals using local vLLM server",
+            "vllm_server": VLLM_SERVER_URL,
+            "endpoints": [
+                "/financial_advice",
+                "/analyze_expenses", 
+                "/calculate_returns",
+                "/health"
+            ]
+        }
+    
+    return api
+
+# Test function to verify vLLM integration
+@app.local_entrypoint()
+def test_vllm_integration():
+    """Test the vLLM integration with a sample financial question"""
+    
+    print(f"Testing vLLM server at: {VLLM_SERVER_URL}")
+    print("Testing vLLM server health...")
+    
+    health = health_check_vllm.remote()
+    print(f"vLLM Health: {health}")
+    
+    if health.get("vllm_status") == "healthy":
+        print("\nTesting simple financial advice generation...")
+        
+        # Start with a very simple question first
+        try:
+            advice = get_financial_advice.remote("What is SIP?", None)
+            print("Generated Advice:")
+            print("=" * 50)
+            print(advice)
+        except Exception as e:
+            print(f"Error during simple test: {e}")
+            
+        print("\nTesting with context...")
+        sample_context = {
+            "salary": 50000,
+            "expenses": {"rent": 15000, "food": 8000, "transport": 3000},
+            "total_expenses": 26000,
+            "remaining_salary": 24000,
+            "savings_goal": "Emergency fund and investments"
+        }
+        
+        try:
+            advice = get_financial_advice.remote(
+                "How should I invest my remaining salary?", 
+                sample_context
+            )
+            print("Generated Advice with Context:")
+            print("=" * 50)
+            print(advice)
+        except Exception as e:
+            print(f"Error during context test: {e}")
+    else:
+        print("vLLM server is not healthy. Please check:")
+        print("1. Is your vLLM server deployed and running?")
+        print("2. Is the VLLM_SERVER_URL correct?")
+        print("3. Is the API_KEY matching?")
+        print(f"Current URL: {VLLM_SERVER_URL}")
+        print(f"Current API Key: {VLLM_API_KEY}")

system_prompt.txt

@@ -0,0 +1,167 @@
+You are MoneyMate, a friendly and knowledgeable financial advisor specifically designed for young Indian professionals who are new to managing their salaries and finances. You are part of a web application that helps users make smart financial decisions through interactive guidance and personalized advice.
+
+## YOUR PERSONALITY & COMMUNICATION STYLE
+
+**Tone & Approach:**
+- Warm, approachable, and encouraging - like a helpful friend who knows about money
+- Use simple, jargon-free language that anyone can understand
+- Be supportive and non-judgmental about past financial decisions
+- Add appropriate emojis (💰🏦📊💡🎯) to make advice engaging and friendly
+- Safety-first approach - always emphasize careful consideration and gradual learning
+- Encourage users to start small and build confidence over time
+
+**Communication Guidelines:**
+- Keep responses conversational but informative
+- Use practical examples with Indian Rupee amounts
+- Break down complex concepts into simple steps
+- Always acknowledge the user's current situation positively
+- Provide specific, actionable advice rather than generic statements
+
+## YOUR EXPERTISE AREAS
+
+**Core Financial Topics:**
+1. **Salary Management:** Budgeting, 50/30/20 rule, expense tracking
+2. **Indian Investments:** SIP, mutual funds, ELSS, PPF, NPS, FDs, bonds
+3. **Tax Planning:** Section 80C, LTCG, tax-saving instruments
+4. **Emergency Planning:** Emergency fund sizing and placement
+5. **Goal-Based Planning:** House, car, vacation, marriage, children's education
+6. **Expense Optimization:** Reducing costs without compromising lifestyle
+7. **Insurance:** Health, term life, and other protection needs
+8. **Retirement Planning:** Early career retirement planning strategies
+
+**Indian Financial Context:**
+- Deep knowledge of Indian financial instruments and regulations
+- Understanding of Indian banking system (SBI, HDFC, ICICI, etc.)
+- Familiarity with Indian mutual fund companies (SBI, HDFC, Axis, etc.)
+- Knowledge of Indian tax laws and implications
+- Awareness of Indian cultural factors affecting financial decisions
+- Understanding of family financial responsibilities common in India
+
+## RESPONSE FORMATTING GUIDELINES
+
+**Structure Your Responses:**
+1. **Acknowledgment:** Briefly acknowledge their situation
+2. **Main Advice:** Provide core recommendations
+3. **Action Steps:** Give specific next steps they can take
+4. **Educational Insight:** Explain why this advice matters
+5. **Safety Note:** Include appropriate disclaimers
+
+**Markdown Formatting:**
+- Use headers (##, ###) to organize long responses
+- Use bullet points for lists and action items
+- Use **bold** for important concepts or amounts
+- Use *italics* for emphasis or explanations
+- Include relevant emojis to make content engaging
+
+**Example Response Structure:**
+```
+## 💰 Great question about [topic]!
+
+Based on your salary of ₹X and expenses of ₹Y, here's what I recommend:
+
+### 🎯 Immediate Action Steps:
+- Step 1 with specific amount/action
+- Step 2 with timeline
+- Step 3 with expected outcome
+
+### 📚 Why This Matters:
+Brief educational explanation of the concept
+
+### ⚠️ Important Considerations:
+- Safety notes or risks to consider
+- When to seek professional help
+```
+
+## SAFETY GUIDELINES & DISCLAIMERS
+
+**Investment Advice Safety:**
+- Never guarantee specific returns or outcomes
+- Always mention that "past performance doesn't guarantee future results"
+- Emphasize the importance of diversification
+- Recommend starting with small amounts to learn
+- Suggest consulting certified financial planners for large decisions
+- Always mention investment risks appropriately
+
+**Standard Disclaimers to Include:**
+- "This is general advice based on your situation. Consider consulting a certified financial planner for personalized strategies."
+- "Start with small amounts and gradually increase as you become more comfortable."
+- "Remember to maintain your emergency fund before making any investments."
+- "Investment markets can be volatile - only invest money you won't need for several years."
+
+## SPECIFIC ADVICE FRAMEWORKS
+
+**For Salary Breakdown Questions:**
+1. Acknowledge their current allocation
+2. Explain the 50/30/20 rule in Indian context
+3. Provide specific rupee amounts for their salary
+4. Suggest gradual adjustments, not dramatic changes
+5. Prioritize emergency fund before investments
+
+**For Investment Questions:**
+1. Assess their risk tolerance and timeline
+2. Start with basics: emergency fund, then SIP
+3. Explain Indian investment options clearly
+4. Provide expected return ranges (realistic, not optimistic)
+5. Emphasize diversification and regular investing
+
+**For Goal-Based Planning:**
+1. Help them quantify the goal amount
+2. Calculate timeline and monthly savings needed
+3. Suggest appropriate investment vehicles
+4. Break down the plan into phases
+5. Provide motivation and milestone tracking
+
+**For Expense Optimization:**
+1. Analyze their expense ratios
+2. Identify 2-3 key areas for improvement
+3. Provide practical, implementable tips
+4. Suggest apps or tools that can help
+5. Emphasize lifestyle balance, not deprivation
+
+## CULTURAL SENSITIVITY & INDIAN CONTEXT
+
+**Family Considerations:**
+- Acknowledge family financial responsibilities
+- Understand joint family financial dynamics
+- Respect cultural values around money and saving
+- Consider social and cultural pressures around spending
+
+**Indian Market Specifics:**
+- Reference familiar brands and institutions
+- Use relevant examples (EMI, festivals, bonus cycles)
+- Understand salary structures (basic, HRA, allowances)
+- Know about common employee benefits (PF, gratuity, health insurance)
+
+**Regional Awareness:**
+- Acknowledge cost of living differences across Indian cities
+- Understand metro vs tier-2/3 city financial challenges
+- Be aware of regional investment preferences and options
+
+## CONVERSATION FLOW GUIDELINES
+
+**For First-Time Users:**
+- Welcome them warmly to financial planning
+- Reassure them that starting is the hardest part
+- Focus on building basic financial habits first
+- Encourage them to ask questions without hesitation
+
+**For Follow-Up Questions:**
+- Reference their previous financial situation if provided
+- Build upon earlier advice given
+- Show progress and encourage continued learning
+- Adapt advice based on their growing knowledge
+
+**For Complex Situations:**
+- Break down into smaller, manageable parts
+- Prioritize the most important actions first
+- Acknowledge when situations require professional help
+- Provide resources for additional learning
+
+## RESPONSE LENGTH & DETAIL
+
+**For Simple Questions:** 2-3 paragraphs with key points
+**For Complex Topics:** Detailed breakdown with sections and action steps
+**For Calculations:** Show the math clearly with examples
+**For Explanations:** Use analogies and real-world examples
+
+Remember: Your goal is to make financial planning accessible, less intimidating, and culturally relevant for young Indian professionals. You're not just giving advice - you're building their financial confidence and literacy for life.

utils.py

@@ -0,0 +1,385 @@
+"""
+Utility functions for MoneyMate financial calculations and validations
+"""
+
+from typing import Dict, List, Tuple, Any
+import re
+from datetime import datetime, timedelta
+
+def validate_salary(salary: float) -> Tuple[bool, str]:
+    """Validate salary input"""
+    if salary <= 0:
+        return False, "Salary must be greater than 0"
+    if salary < 10000:
+        return False, "Salary seems too low. Please enter monthly salary in Indian Rupees"
+    if salary > 10000000:  # 1 crore
+        return False, "Salary seems too high. Please verify the amount"
+    return True, "Valid salary"
+
+def validate_expenses(expenses: Dict[str, float], salary: float) -> Tuple[bool, str, List[str]]:
+    """Validate expense inputs"""
+    warnings = []
+    total_expenses = sum(expenses.values())
+    
+    # Check if total expenses exceed salary
+    if total_expenses > salary:
+        return False, f"Total expenses (₹{total_expenses:,.0f}) exceed salary (₹{salary:,.0f})", warnings
+    
+    # Check individual expense categories
+    for category, amount in expenses.items():
+        if amount < 0:
+            return False, f"{category} cannot be negative", warnings
+        
+        # Category-specific validations
+        category_lower = category.lower()
+        percentage = (amount / salary) * 100 if salary > 0 else 0
+        
+        if category_lower == "rent" and percentage > 50:
+            warnings.append(f"Rent is {percentage:.1f}% of salary - consider reducing housing costs")
+        elif category_lower == "food" and percentage > 30:
+            warnings.append(f"Food expenses are {percentage:.1f}% of salary - try cooking at home more")
+        elif category_lower == "entertainment" and percentage > 20:
+            warnings.append(f"Entertainment is {percentage:.1f}% of salary - consider budgeting")
+    
+    return True, "Valid expenses", warnings
+
+def calculate_50_30_20_breakdown(salary: float) -> Dict[str, float]:
+    """Calculate 50/30/20 rule breakdown"""
+    return {
+        "needs": salary * 0.50,
+        "wants": salary * 0.30,
+        "savings": salary * 0.20
+    }
+
+def calculate_emergency_fund_target(monthly_expenses: float, months: int = 6) -> Dict[str, Any]:
+    """Calculate emergency fund target"""
+    target_amount = monthly_expenses * months
+    
+    return {
+        "target_amount": target_amount,
+        "months_coverage": months,
+        "monthly_expenses": monthly_expenses,
+        "recommendation": f"Build emergency fund of ₹{target_amount:,.0f} ({months} months of expenses)"
+    }
+
+def calculate_sip_returns(
+    monthly_amount: float,
+    annual_return: float,
+    years: int,
+    inflation_rate: float = 6.0
+) -> Dict[str, Any]:
+    """Calculate SIP returns with inflation adjustment"""
+    
+    months = years * 12
+    monthly_return = annual_return / 12 / 100
+    monthly_inflation = inflation_rate / 12 / 100
+    
+    # Future value calculation
+    if monthly_return > 0:
+        future_value = monthly_amount * (((1 + monthly_return) ** months - 1) / monthly_return) * (1 + monthly_return)
+    else:
+        future_value = monthly_amount * months
+    
+    total_invested = monthly_amount * months
+    absolute_returns = future_value - total_invested
+    
+    # Inflation-adjusted value
+    inflation_adjusted_value = future_value / ((1 + monthly_inflation) ** months)
+    real_returns = inflation_adjusted_value - total_invested
+    
+    return {
+        "future_value": round(future_value, 2),
+        "total_invested": round(total_invested, 2),
+        "absolute_returns": round(absolute_returns, 2),
+        "inflation_adjusted_value": round(inflation_adjusted_value, 2),
+        "real_returns": round(real_returns, 2),
+        "return_percentage": round((absolute_returns / total_invested) * 100, 2) if total_invested > 0 else 0,
+        "real_return_percentage": round((real_returns / total_invested) * 100, 2) if total_invested > 0 else 0,
+        "years": years,
+        "monthly_investment": monthly_amount
+    }
+
+def get_tax_saving_instruments() -> List[Dict[str, Any]]:
+    """Get list of tax-saving instruments under Section 80C"""
+    return [
+        {
+            "name": "ELSS Mutual Funds",
+            "lock_in": "3 years",
+            "expected_return": "10-12%",
+            "risk": "Medium to High",
+            "liquidity": "Low (until lock-in)",
+            "description": "Equity-linked savings schemes with tax benefits"
+        },
+        {
+            "name": "PPF (Public Provident Fund)",
+            "lock_in": "15 years",
+            "expected_return": "7-8%",
+            "risk": "Very Low",
+            "liquidity": "Very Low",
+            "description": "Government-backed long-term savings with tax-free returns"
+        },
+        {
+            "name": "NSC (National Savings Certificate)",
+            "lock_in": "5 years",
+            "expected_return": "6-7%",
+            "risk": "Very Low",
+            "liquidity": "Low",
+            "description": "Government savings certificate with fixed returns"
+        },
+        {
+            "name": "Life Insurance Premium",
+            "lock_in": "Varies",
+            "expected_return": "4-6%",
+            "risk": "Low",
+            "liquidity": "Low to Medium",
+            "description": "Term/whole life insurance premiums qualify for deduction"
+        },
+        {
+            "name": "Home Loan Principal",
+            "lock_in": "Loan tenure",
+            "expected_return": "Property appreciation",
+            "risk": "Medium",
+            "liquidity": "Low",
+            "description": "Principal repayment of home loan qualifies for deduction"
+        }
+    ]
+
+def get_investment_allocation_by_age(age: int) -> Dict[str, Any]:
+    """Get recommended investment allocation based on age"""
+    
+    if age < 25:
+        equity_percentage = 80
+        debt_percentage = 20
+        risk_profile = "High"
+    elif age < 35:
+        equity_percentage = 70
+        debt_percentage = 30
+        risk_profile = "Medium to High"
+    elif age < 45:
+        equity_percentage = 60
+        debt_percentage = 40
+        risk_profile = "Medium"
+    elif age < 55:
+        equity_percentage = 50
+        debt_percentage = 50
+        risk_profile = "Medium to Low"
+    else:
+        equity_percentage = 30
+        debt_percentage = 70
+        risk_profile = "Low"
+    
+    return {
+        "age": age,
+        "equity_percentage": equity_percentage,
+        "debt_percentage": debt_percentage,
+        "risk_profile": risk_profile,
+        "rationale": f"At age {age}, you can take {risk_profile.lower()} risk with {equity_percentage}% equity allocation"
+    }
+
+def calculate_goal_based_savings(
+    goal_amount: float,
+    current_savings: float,
+    timeline_years: float,
+    expected_return: float = 12.0
+) -> Dict[str, Any]:
+    """Calculate monthly savings needed for a financial goal"""
+    
+    timeline_months = int(timeline_years * 12)
+    monthly_return = expected_return / 12 / 100
+    
+    # Amount needed to invest
+    amount_needed = goal_amount - current_savings
+    
+    if amount_needed <= 0:
+        return {
+            "goal_amount": goal_amount,
+            "current_savings": current_savings,
+            "amount_needed": 0,
+            "monthly_required": 0,
+            "timeline_months": timeline_months,
+            "status": "Goal already achieved!",
+            "recommendation": "Consider setting a higher goal or investing surplus for other objectives"
+        }
+    
+    # Calculate monthly SIP required
+    if monthly_return > 0:
+        # PMT formula for SIP calculation
+        monthly_sip = amount_needed * monthly_return / (((1 + monthly_return) ** timeline_months - 1) * (1 + monthly_return))
+    else:
+        monthly_sip = amount_needed / timeline_months
+    
+    # Determine feasibility
+    if monthly_sip < 1000:
+        feasibility = "Very Easy"
+    elif monthly_sip < 5000:
+        feasibility = "Easy"
+    elif monthly_sip < 15000:
+        feasibility = "Moderate"
+    elif monthly_sip < 30000:
+        feasibility = "Challenging"
+    else:
+        feasibility = "Very Challenging"
+    
+    return {
+        "goal_amount": goal_amount,
+        "current_savings": current_savings,
+        "amount_needed": amount_needed,
+        "monthly_required": round(monthly_sip, 2),
+        "timeline_months": timeline_months,
+        "timeline_years": timeline_years,
+        "expected_return": expected_return,
+        "feasibility": feasibility,
+        "recommendation": get_goal_recommendation(monthly_sip, feasibility)
+    }
+
+def get_goal_recommendation(monthly_sip: float, feasibility: str) -> str:
+    """Get recommendation based on goal feasibility"""
+    if feasibility == "Very Easy":
+        return f"Great! ₹{monthly_sip:,.0f} per month is very manageable. Consider increasing the goal or timeline."
+    elif feasibility == "Easy":
+        return f"₹{monthly_sip:,.0f} per month should be comfortable. Start a SIP immediately."
+    elif feasibility == "Moderate":
+        return f"₹{monthly_sip:,.0f} per month requires discipline. Create a budget and automate your investments."
+    elif feasibility == "Challenging":
+        return f"₹{monthly_sip:,.0f} per month is ambitious. Consider extending timeline or reducing goal amount."
+    else:
+        return f"₹{monthly_sip:,.0f} per month seems unrealistic. Reassess your goal amount or timeline."
+
+def get_expense_optimization_tips(expenses: Dict[str, float], salary: float) -> List[str]:
+    """Get personalized expense optimization tips"""
+    tips = []
+    
+    for category, amount in expenses.items():
+        percentage = (amount / salary) * 100 if salary > 0 else 0
+        category_lower = category.lower()
+        
+        if category_lower == "rent" and percentage > 30:
+            tips.extend([
+                "🏠 Consider sharing accommodation or moving to a less expensive area",
+                "🏠 Negotiate rent with landlord or look for better deals",
+                "🏠 Explore PG/hostel options if you're single"
+            ])
+        
+        elif category_lower == "food" and percentage > 20:
+            tips.extend([
+                "🍽️ Cook at home more often - it's healthier and cheaper",
+                "🍽️ Meal prep on weekends to avoid ordering food",
+                "🍽️ Use grocery apps for discounts and bulk buying"
+            ])
+        
+        elif category_lower == "transport" and percentage > 15:
+            tips.extend([
+                "🚗 Use public transport or carpool to save money",
+                "🚗 Consider a bike/scooter if you frequently use cabs",
+                "🚗 Work from home when possible to reduce commute costs"
+            ])
+        
+        elif category_lower == "entertainment" and percentage > 15:
+            tips.extend([
+                "🎬 Set a monthly entertainment budget and stick to it",
+                "🎬 Look for free/low-cost activities like parks, museums",
+                "🎬 Use streaming services instead of frequent movie outings"
+            ])
+    
+    # Add general tips
+    general_tips = [
+        "📱 Review and cancel unused subscriptions",
+        "💡 Use energy-efficient appliances to reduce utility bills",
+        "🛒 Make a shopping list and stick to it to avoid impulse purchases",
+        "💳 Use credit cards wisely - pay full amount to avoid interest",
+        "🏪 Compare prices before making major purchases"
+    ]
+    
+    tips.extend(general_tips[:3])  # Add 3 general tips
+    
+    return list(set(tips))  # Remove duplicates
+
+def format_currency(amount: float) -> str:
+    """Format amount in Indian currency format"""
+    if amount >= 10000000:  # 1 crore
+        return f"₹{amount/10000000:.1f} Cr"
+    elif amount >= 100000:  # 1 lakh
+        return f"₹{amount/100000:.1f} L"
+    elif amount >= 1000:  # 1 thousand
+        return f"₹{amount/1000:.1f} K"
+    else:
+        return f"₹{amount:,.0f}"
+
+def get_financial_milestones_by_age() -> Dict[int, List[str]]:
+    """Get financial milestones by age group"""
+    return {
+        25: [
+            "Build emergency fund of 3-6 months expenses",
+            "Start investing in equity mutual funds via SIP",
+            "Get health insurance coverage",
+            "Begin tax planning with ELSS/PPF"
+        ],
+        30: [
+            "Emergency fund of 6-12 months expenses",
+            "Diversified investment portfolio worth 2-3x annual salary",
+            "Term life insurance coverage",
+            "Start planning for major goals (house, marriage)"
+        ],
+        35: [
+            "Net worth of 5-7x annual salary",
+            "Own house or significant progress towards it",
+            "Children's education planning started",
+            "Retirement planning begun"
+        ],
+        40: [
+            "Net worth of 8-10x annual salary",
+            "Debt-to-income ratio below 30%",
+            "Children's education fund secured",
+            "Aggressive retirement planning"
+        ],
+        45: [
+            "Net worth of 12-15x annual salary",
+            "House loan paid off or nearing completion",
+            "Children's higher education funded",
+            "Retirement corpus building accelerated"
+        ]
+    }
+
+def calculate_retirement_corpus(
+    current_age: int,
+    retirement_age: int,
+    current_monthly_expenses: float,
+    inflation_rate: float = 6.0,
+    withdrawal_rate: float = 4.0
+) -> Dict[str, Any]:
+    """Calculate retirement corpus requirement"""
+    
+    years_to_retirement = retirement_age - current_age
+    
+    if years_to_retirement <= 0:
+        return {"error": "Retirement age should be greater than current age"}
+    
+    # Future value of current expenses
+    future_monthly_expenses = current_monthly_expenses * ((1 + inflation_rate/100) ** years_to_retirement)
+    future_annual_expenses = future_monthly_expenses * 12
+    
+    # Corpus required (using 4% rule)
+    corpus_required = future_annual_expenses / (withdrawal_rate / 100)
+    
+    return {
+        "current_age": current_age,
+        "retirement_age": retirement_age,
+        "years_to_retirement": years_to_retirement,
+        "current_monthly_expenses": current_monthly_expenses,
+        "future_monthly_expenses": round(future_monthly_expenses, 2),
+        "corpus_required": round(corpus_required, 2),
+        "corpus_in_crores": round(corpus_required / 10000000, 2),
+        "monthly_sip_required": round(calculate_sip_for_target(corpus_required, years_to_retirement), 2)
+    }
+
+def calculate_sip_for_target(target_amount: float, years: int, expected_return: float = 12.0) -> float:
+    """Calculate monthly SIP required to reach target amount"""
+    months = years * 12
+    monthly_return = expected_return / 12 / 100
+    
+    if monthly_return > 0:
+        monthly_sip = target_amount * monthly_return / (((1 + monthly_return) ** months - 1) * (1 + monthly_return))
+    else:
+        monthly_sip = target_amount / months
+    
+    return monthly_sip

vllm_inference.py

@@ -0,0 +1,69 @@
+import modal
+
+vllm_image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "vllm==0.7.2",
+        "huggingface_hub[hf_transfer]==0.26.2",
+        "flashinfer-python==0.2.0.post2",  # pinning, very unstable
+        extra_index_url="https://flashinfer.ai/whl/cu124/torch2.5",
+    )
+    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})  # faster model transfers
+)
+
+
+vllm_image = vllm_image.env({"VLLM_USE_V1": "1"})
+
+
+MODELS_DIR = "/llamas"
+MODEL_NAME = "neuralmagic/Meta-Llama-3.1-8B-Instruct-quantized.w4a16"
+MODEL_REVISION = "a7c09948d9a632c2c840722f519672cd94af885d"
+
+hf_cache_vol = modal.Volume.from_name("huggingface-cache", create_if_missing=True)
+vllm_cache_vol = modal.Volume.from_name("vllm-cache", create_if_missing=True)
+
+
+
+app = modal.App("example-vllm-openai-compatible")
+
+N_GPU = 2  # tip: for best results, first upgrade to more powerful GPUs, and only then increase GPU count
+API_KEY = "super-secret-key"  # api key, for auth. for production use, replace with a modal.Secret
+
+MINUTES = 60  # seconds
+
+VLLM_PORT = 8000
+
+
+@app.function(
+    image=vllm_image,
+    gpu=f"H100:{N_GPU}",
+    scaledown_window=15 * MINUTES,  # how long should we stay up with no requests?
+    timeout=10 * MINUTES,  # how long should we wait for container start?
+    volumes={
+        "/root/.cache/huggingface": hf_cache_vol,
+        "/root/.cache/vllm": vllm_cache_vol,
+    },
+)
+@modal.concurrent(
+    max_inputs=100
+)  # how many requests can one replica handle? tune carefully!
+@modal.web_server(port=VLLM_PORT, startup_timeout=5 * MINUTES)
+def serve():
+    import subprocess
+
+    cmd = [
+        "vllm",
+        "serve",
+        "--uvicorn-log-level=info",
+        MODEL_NAME,
+        "--revision",
+        MODEL_REVISION,
+        "--host",
+        "0.0.0.0",
+        "--port",
+        str(VLLM_PORT),
+        "--api-key",
+        API_KEY,
+    ]
+
+    subprocess.Popen(" ".join(cmd), shell=True)