Refactor financial tools: removed expense tracker functionality, updated budget planner keywords, and improved README with new tags and demo video link.

README.md

@@ -6,6 +6,11 @@ colorTo: blue
 sdk: gradio
 sdk_version: 5.33.0
 app_file: app.py
+tags:
+  - mcp-server-track
+  - financial-analysis
+  - openai
+  - tavily
 pinned: false
 license: apache-2.0
 short_description: Financial analysis, investments, budget planning, and more.
@@ -16,6 +21,11 @@ short_description: Financial analysis, investments, budget planning, and more.
 
 An intelligent financial advisory agent powered by OpenAI's GPT-4.1 and specialized financial tools. This agent provides comprehensive financial analysis, investment recommendations, budget planning, and market insights through an intuitive web interface.
 
+<!-- **Watch the demo video:** [Code Analysis MCP Demo (Agents MCP Hackathon)](https://www.youtube.com/watch?v=A4YWMMyJRsA)
+
+
+[![Watch the demo on YouTube](image.png)](https://youtu.be/A4YWMMyJRsA) -->
+
 ## 🚀 Features
 
 ### Core Financial Tools
@@ -92,13 +102,6 @@ python app.py
 "Detailed portfolio analysis for my current investments"
 ```
 
-#### Expense Tracker
-```
-"Track my expenses: [{'category': 'food', 'amount': 150}, {'category': 'gas', 'amount': 80}]"
-"Analyze my spending patterns from last month"
-"Help me categorize and analyze my expenses"
-```
-
 ### Response Type Control
 
 #### Short Responses (Under 200 words)

agents/financial_agent.py

@@ -29,7 +29,6 @@ class FinancialAdvisorAgent:
 Available tools:
 - budget_planner: Use when users ask about budgeting, income allocation, or expense planning. Input should be JSON with 'income' and 'expenses' keys.
 - investment_analyzer: Use when users ask about specific stocks or investments. Input should be a stock symbol (e.g., AAPL).
-- expense_tracker: Use when users want to track or analyze expenses. Input should be JSON with 'expenses' array.
 - market_trends: Use when users ask about market trends or financial news. Input should be a search query.
 - portfolio_analyzer: Use when users want to analyze their portfolio. Input should be JSON with 'holdings' array.
 
@@ -134,11 +133,10 @@ When a user asks a question:
         # Check if this is a multi-tool query (contains keywords for multiple tools)
         message_lower = message.lower()
         tool_keywords = {
-            "budget_planner": ["budget", "income", "expense", "spending", "allocat"],
+            "budget_planner": ["budget", "income", "expense", "spending", "allocat", "track", "categoriz"],
             "investment_analyzer": ["stock", "invest", "buy", "sell", "analyze"],
             "portfolio_analyzer": ["portfolio", "holdings", "allocation", "diversif"],
-            "market_trends": ["market", "trend", "news", "sector", "economic"],
-            "expense_tracker": ["track", "expense", "spending", "categoriz"]
+            "market_trends": ["market", "trend", "news", "sector", "economic"]
         }
         
         detected_tools = []

agents/tools.py

@@ -16,8 +16,21 @@ class FinancialTools:
         def budget_planner(input_str: str) -> str:
             """Create a personalized budget plan with advanced features"""
             try:
-                data = json.loads(input_str)
-                income = data.get("income", 0)
+                # Handle empty or invalid input
+                if not input_str or input_str.strip() == "":
+                    input_str = '{"income": 5000, "expenses": {}}'
+                
+                # Try to parse JSON, if it fails, try to extract values from text
+                try:
+                    data = json.loads(input_str)
+                except json.JSONDecodeError:
+                    # Fallback: extract income and expenses from text
+                    import re
+                    income_match = re.search(r'(\$?[\d,]+(?:\.\d{2})?)', input_str)
+                    income = float(income_match.group(1).replace('$', '').replace(',', '')) if income_match else 5000
+                    data = {"income": income, "expenses": {}}
+                
+                income = data.get("income", 5000)
                 expenses = data.get("expenses", {})
                 goals = data.get("savings_goals", {})
                 debt = data.get("debt", {})
@@ -300,172 +313,6 @@ class FinancialTools:
             func=investment_analyzer,
         )
 
-    def create_expense_tracker(self) -> Tool:
-        def expense_tracker(input_str: str) -> str:
-            """Track and analyze expenses with advanced insights, trends, and predictions"""
-            try:
-                data = json.loads(input_str)
-                expenses = data.get("expenses", [])
-                historical_data = data.get("historical_expenses", [])
-                budget_limits = data.get("budget_limits", {})
-
-                # Combine current and historical data
-                all_expenses = expenses + historical_data
-                df = pd.DataFrame(all_expenses)
-
-                if df.empty:
-                    return "No expense data provided"
-
-                # Ensure date column exists and is properly formatted
-                if "date" in df.columns:
-                    df["date"] = pd.to_datetime(df["date"])
-                    df = df.sort_values("date")
-                else:
-                    # Add current date for expenses without dates
-                    df["date"] = datetime.now()
-
-                # Current period analysis
-                current_df = pd.DataFrame(expenses) if expenses else pd.DataFrame()
-                total_current = current_df["amount"].sum() if not current_df.empty else 0
-
-                # Category analysis
-                category_summary = df.groupby("category")["amount"].agg(["sum", "mean", "count", "std"]).to_dict("index")
-                
-                # Trend analysis (if historical data available)
-                trends = {}
-                predictions = {}
-                
-                if len(df) > 1 and "date" in df.columns:
-                    # Monthly spending trends
-                    df["month"] = df["date"].dt.to_period("M")
-                    monthly_spending = df.groupby("month")["amount"].sum()
-                    
-                    if len(monthly_spending) > 1:
-                        # Calculate month-over-month growth
-                        mom_growth = monthly_spending.pct_change().iloc[-1] * 100
-                        trends["monthly_growth"] = f"{mom_growth:.1f}%"
-                        
-                        # Simple linear trend prediction for next month
-                        if len(monthly_spending) >= 3:
-                            recent_trend = monthly_spending.tail(3).mean()
-                            predictions["next_month_estimate"] = f"${recent_trend:.2f}"
-
-                    # Category trends
-                    for category in df["category"].unique():
-                        cat_data = df[df["category"] == category].groupby("month")["amount"].sum()
-                        if len(cat_data) > 1:
-                            cat_trend = cat_data.pct_change().iloc[-1] * 100
-                            trends[f"{category}_trend"] = f"{cat_trend:.1f}%"
-
-                # Spending pattern analysis
-                if "date" in df.columns:
-                    df["day_of_week"] = df["date"].dt.day_name()
-                    df["hour"] = df["date"].dt.hour
-                    
-                    spending_patterns = {
-                        "busiest_day": df.groupby("day_of_week")["amount"].sum().idxmax(),
-                        "peak_spending_hour": df.groupby("hour")["amount"].sum().idxmax(),
-                    }
-                else:
-                    spending_patterns = {}
-
-                # Budget analysis
-                budget_analysis = {}
-                if budget_limits:
-                    for category, limit in budget_limits.items():
-                        cat_spending = category_summary.get(category, {}).get("sum", 0)
-                        budget_analysis[category] = {
-                            "limit": f"${limit:.2f}",
-                            "spent": f"${cat_spending:.2f}",
-                            "remaining": f"${max(0, limit - cat_spending):.2f}",
-                            "percentage_used": f"{(cat_spending / limit * 100):.1f}%" if limit > 0 else "N/A",
-                            "status": "Over Budget" if cat_spending > limit else "Within Budget"
-                        }
-
-                # Anomaly detection (expenses significantly above average)
-                anomalies = []
-                if not df.empty:
-                    for category in df["category"].unique():
-                        cat_data = df[df["category"] == category]["amount"]
-                        if len(cat_data) > 2:
-                            mean_spending = cat_data.mean()
-                            std_spending = cat_data.std()
-                            threshold = mean_spending + (2 * std_spending)
-                            
-                            recent_anomalies = cat_data[cat_data > threshold]
-                            if not recent_anomalies.empty:
-                                anomalies.append({
-                                    "category": category,
-                                    "unusual_amount": f"${recent_anomalies.iloc[-1]:.2f}",
-                                    "typical_range": f"${mean_spending:.2f} ± ${std_spending:.2f}"
-                                })
-
-                # Generate insights and recommendations
-                insights = []
-                recommendations = []
-
-                # Top spending categories
-                top_categories = sorted(category_summary.items(), key=lambda x: x[1]["sum"], reverse=True)[:3]
-                category_strings = [f'{cat} (${data["sum"]:.2f})' for cat, data in top_categories]
-                insights.append(f"Top 3 spending categories: {', '.join(category_strings)}")
-
-                # Spending frequency analysis
-                if not df.empty:
-                    avg_transaction = df["amount"].mean()
-                    insights.append(f"Average transaction: ${avg_transaction:.2f}")
-                    
-                    if avg_transaction > 100:
-                        recommendations.append("Consider breaking down large expenses into smaller, more frequent transactions for better budget control")
-
-                # Trend-based recommendations
-                if "monthly_growth" in trends:
-                    growth = float(trends["monthly_growth"].rstrip("%"))
-                    if growth > 10:
-                        recommendations.append(f"Spending increased {growth:.1f}% this month. Review discretionary expenses.")
-                    elif growth < -10:
-                        recommendations.append(f"Good job! Spending decreased {abs(growth):.1f}% this month.")
-
-                # Budget recommendations
-                for category, analysis in budget_analysis.items():
-                    if "Over Budget" in analysis["status"]:
-                        recommendations.append(f"Reduce {category} spending - currently over budget")
-                    elif float(analysis["percentage_used"].rstrip("%")) > 80:
-                        recommendations.append(f"Approaching {category} budget limit ({analysis['percentage_used']})")
-
-                analysis_result = {
-                    "current_period": {
-                        "total_expenses": f"${total_current:.2f}",
-                        "transaction_count": len(current_df) if not current_df.empty else 0,
-                        "average_transaction": f"${(total_current / len(current_df)):.2f}" if not current_df.empty else "$0.00",
-                    },
-                    "category_analysis": {
-                        category: {
-                            "total": f"${data['sum']:.2f}",
-                            "average": f"${data['mean']:.2f}",
-                            "transactions": int(data['count']),
-                            "variability": f"${data.get('std', 0):.2f}"
-                        } for category, data in category_summary.items()
-                    },
-                    "trends": trends,
-                    "predictions": predictions,
-                    "spending_patterns": spending_patterns,
-                    "budget_analysis": budget_analysis,
-                    "anomalies": anomalies,
-                    "insights": insights,
-                    "recommendations": recommendations,
-                    "analysis_date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                }
-
-                return json.dumps(analysis_result, indent=2)
-
-            except Exception as e:
-                return f"Error tracking expenses: {str(e)}"
-
-        return Tool(
-            name="expense_tracker",
-            description="Track and analyze expenses with detailed insights",
-            func=expense_tracker,
-        )
 
     def create_market_trends_analyzer(self) -> Tool:
         def market_trends(query: str) -> str:
@@ -690,7 +537,6 @@ class FinancialTools:
         return [
             self.create_budget_planner(),
             self.create_investment_analyzer(),
-            self.create_expense_tracker(),
             self.create_market_trends_analyzer(),
             self.create_portfolio_analyzer(),
         ]

app.py

@@ -414,17 +414,15 @@ def determine_intended_tool(message):
     message_lower = message.lower()
     
     tool_detection_map = {
-        "budget_planner": ["budget", "income", "expense", "spending", "allocat", "monthly", "plan", "financial plan", "money"],
+        "budget_planner": ["budget", "income", "expense", "spending", "allocat", "monthly", "plan", "financial plan", "money", "track", "categoriz", "cost"],
         "investment_analyzer": ["stock", "invest", "buy", "sell", "analyze", "AAPL", "GOOGL", "TSLA", "share", "equity"],
         "portfolio_analyzer": ["portfolio", "holdings", "allocation", "diversif", "asset", "position"],
-        "market_trends": ["market", "trend", "news", "sector", "economic", "latest", "current"],
-        "expense_tracker": ["track", "expense", "spending", "categoriz", "cost"]
+        "market_trends": ["market", "trend", "news", "sector", "economic", "latest", "current"]
     }
     
     tool_names = {
         "budget_planner": "Budget Planner",
-        "investment_analyzer": "Investment Analyzer", 
-        "expense_tracker": "Expense Tracker",
+        "investment_analyzer": "Investment Analyzer",
         "market_trends": "Market Trends Analyzer",
         "portfolio_analyzer": "Portfolio Analyzer",
     }
@@ -512,8 +510,6 @@ def process_financial_query(message, history):
                 status_msg = f"💰 Processing budget analysis (estimated 5-10 seconds)..."
             elif intended_tool_key == "portfolio_analyzer":
                 status_msg = f"📊 Analyzing portfolio data (estimated 8-12 seconds)..."
-            elif intended_tool_key == "expense_tracker":
-                status_msg = f"💳 Processing expense analysis (estimated 5-10 seconds)..."
             else:
                 status_msg = f"🔄 Using {intended_tool_name} (estimated 5-15 seconds)..."
             
@@ -539,16 +535,14 @@ def process_financial_query(message, history):
             
             tool_names = {
                 "budget_planner": "Budget Planner",
-                "investment_analyzer": "Investment Analyzer", 
-                "expense_tracker": "Expense Tracker",
+                "investment_analyzer": "Investment Analyzer",
                 "market_trends": "Market Trends Analyzer",
                 "portfolio_analyzer": "Portfolio Analyzer",
             }
             
             tool_emojis = {
                 "Budget Planner": "💰",
-                "Investment Analyzer": "📈", 
-                "Expense Tracker": "💳",
+                "Investment Analyzer": "📈",
                 "Market Trends Analyzer": "📰",
                 "Portfolio Analyzer": "📊",
             }
@@ -744,4 +738,4 @@ with gr.Blocks(theme=gr.themes.Base(), title="Financial Advisory Agent") as demo
     chatbot.like(like_handler)
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch()