Spaces:
Running
Running
| 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 | |
| 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"} | |
| } | |
| } | |
| } | |
| ] | |
| } | |
| 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 | |
| ) | |