Refactor portfolio analyzer in FinancialTools: simplified input extraction and handling, improved default portfolio logic, and enhanced analysis output with basic recommendations for diversification.

agents/financial_agent.py

@@ -113,32 +113,7 @@ When a user asks a question:
             return json.dumps({"income": income, "expenses": expenses})
 
         elif tool_name == "portfolio_analyzer":
-            # Try to extract portfolio data from message
-            import re
-            
-            # Look for JSON-like structure in message
-            json_match = re.search(r'\{.*\}|\[.*\]', message, re.DOTALL)
-            if json_match:
-                try:
-                    # Try to parse the extracted JSON
-                    potential_json = json_match.group(0)
-                    parsed_data = json.loads(potential_json)
-                    return json.dumps(parsed_data)
-                except:
-                    pass
-            
-            # Look for simple symbol mentions like "AAPL 100 shares, GOOGL 50 shares"
-            symbol_pattern = r'([A-Z]{2,5})\s+(\d+)\s*(?:shares?)?'
-            matches = re.findall(symbol_pattern, message, re.I)
-            
-            if matches:
-                holdings = []
-                for symbol, shares in matches:
-                    holdings.append({"symbol": symbol.upper(), "shares": int(shares)})
-                return json.dumps({"holdings": holdings})
-            
-            # Default portfolio for demo
-            return json.dumps({"holdings": [{"symbol": "AAPL", "shares": 100}, {"symbol": "GOOGL", "shares": 50}]})
+            return message
 
         elif tool_name == "market_trends":
             return message

agents/tools.py

@@ -465,105 +465,82 @@ class FinancialTools:
         def portfolio_analyzer(input_str: str) -> str:
             """Analyze portfolio performance and diversification"""
             try:
-                data = json.loads(input_str)
+                # Simple extraction from user message
+                import re
                 
-                # Handle different input formats
-                if isinstance(data, list):
-                    # Input is directly a list of holdings
-                    holdings = data
-                elif isinstance(data, dict):
-                    # Input is a dict with 'holdings' key
-                    holdings = data.get("holdings", [])
-                else:
-                    holdings = []
+                # Look for JSON in the input
+                json_match = re.search(r'\{.*\}|\[.*\]', input_str, re.DOTALL)
+                holdings = []
+                
+                if json_match:
+                    try:
+                        data = json.loads(json_match.group(0))
+                        if isinstance(data, list):
+                            holdings = data
+                        elif isinstance(data, dict) and "holdings" in data:
+                            holdings = data["holdings"]
+                    except:
+                        pass
+                
+                # If no JSON found, use default example
+                if not holdings:
+                    holdings = [
+                        {"symbol": "AAPL", "shares": 100},
+                        {"symbol": "GOOGL", "shares": 50}
+                    ]
 
                 total_value = 0
                 portfolio_data = []
 
+                # Fetch data for each holding
                 for holding in holdings:
-                    # Handle different holding formats
-                    if isinstance(holding, dict):
-                        symbol = holding.get("symbol", "")
-                        shares = holding.get("shares", 0)
-                    else:
-                        # Skip invalid holdings
-                        continue
+                    symbol = holding.get("symbol", "")
+                    shares = holding.get("shares", 0)
                     
                     if not symbol:
                         continue
 
                     try:
+                        # Simple yfinance call when needed
                         stock = yf.Ticker(symbol)
-                        info = stock.info
-                        current_price = info.get("currentPrice", 0)
+                        hist = stock.history(period="1d")
                         
-                        # Fallback for current price if not available
-                        if current_price == 0:
-                            hist = stock.history(period="1d")
-                            if not hist.empty:
-                                current_price = hist["Close"].iloc[-1]
-                        
-                        value = current_price * shares
-                        total_value += value
+                        if not hist.empty:
+                            current_price = hist["Close"].iloc[-1]
+                            value = current_price * shares
+                            total_value += value
 
-                        portfolio_data.append(
-                            {
+                            portfolio_data.append({
                                 "symbol": symbol,
                                 "shares": shares,
-                                "current_price": current_price,
+                                "current_price": f"${current_price:.2f}",
                                 "value": value,
-                                "sector": info.get("sector", "Unknown"),
-                            }
-                        )
-                    except Exception as e:
-                        # Handle individual stock errors gracefully
-                        portfolio_data.append(
-                            {
-                                "symbol": symbol,
-                                "shares": shares,
-                                "current_price": 0,
-                                "value": 0,
-                                "sector": "Unknown",
-                                "error": f"Failed to fetch data: {str(e)}"
-                            }
-                        )
+                                "allocation": 0  # Will calculate after
+                            })
+                    except:
+                        # Skip if can't get data
+                        continue
 
                 # Calculate allocations
                 for item in portfolio_data:
-                    item["allocation"] = (
-                        (item["value"] / total_value * 100) if total_value > 0 else 0
-                    )
-
-                # Sector diversification
-                df = pd.DataFrame(portfolio_data)
-                # Handle case where portfolio_data is empty or sector column has issues
-                if not df.empty and "sector" in df.columns:
-                    sector_allocation = df.groupby("sector")["allocation"].sum().to_dict()
-                else:
-                    sector_allocation = {}
+                    item["allocation"] = (item["value"] / total_value * 100) if total_value > 0 else 0
 
+                # Simple analysis
                 analysis = {
                     "total_portfolio_value": f"${total_value:.2f}",
+                    "number_of_holdings": len(portfolio_data),
                     "holdings": portfolio_data,
-                    "sector_allocation": sector_allocation,
-                    "diversification_score": len(sector_allocation)
-                    / 11
-                    * 100,  # 11 major sectors
-                    "recommendations": [],
+                    "recommendations": []
                 }
 
-                # Add recommendations
-                if len(holdings) < 5:
-                    analysis["recommendations"].append(
-                        "Consider diversifying with more holdings"
-                    )
-
+                # Basic recommendations
+                if len(portfolio_data) < 5:
+                    analysis["recommendations"].append("Consider diversifying with more holdings")
+                
                 if portfolio_data:
                     max_allocation = max(item["allocation"] for item in portfolio_data)
                     if max_allocation > 30:
-                        analysis["recommendations"].append(
-                            f"High concentration risk: largest holding is {max_allocation:.1f}%"
-                        )
+                        analysis["recommendations"].append(f"High concentration risk: largest holding is {max_allocation:.1f}%")
 
                 return json.dumps(analysis, indent=2)
 
@@ -572,7 +549,7 @@ class FinancialTools:
 
         return Tool(
             name="portfolio_analyzer",
-            description="Analyze portfolio performance and diversification",
+            description="Analyze portfolio performance and diversification. Input should include holdings like: [{'symbol': 'AAPL', 'shares': 100}]",
             func=portfolio_analyzer,
         )
 

app.py

@@ -675,7 +675,7 @@ def process_financial_query(message, history):
 
 # Create the Gradio interface
 with gr.Blocks(theme=gr.themes.Base(), title="Financial Advisory Agent") as demo:
-    gr.Markdown("""<center><img src="/gradio_api/file=public/images/fin_logo.png" alt="Fin Logo" style="width: 50px; vertical-align: middle;">
+    gr.HTML("""<center><img src="/gradio_api/file=public/images/fin_logo.png" alt="Fin Logo" style="width: 50px; vertical-align: middle;">
     <h1 style="text-align: center;">AI Financial Advisory Agent</h1>
     Your AI-powered financial advisor for budgeting, investments, expense tracking, portfolio analysis, and market trends.
                 </center>