Update README.md to enhance project description, add detailed features, installation instructions, example prompts, and technical architecture for the Financial Advisory Agent. Changed emoji and color scheme for better representation.

.gitignore

@@ -0,0 +1,194 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the enitre vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

README.md

@@ -1,8 +1,8 @@
 ---
 title: Financial Advisory Agent
-emoji: 👀
+emoji: 🧑‍💼
 colorFrom: gray
-colorTo: red
+colorTo: blue
 sdk: gradio
 sdk_version: 5.33.0
 app_file: app.py
@@ -11,4 +11,213 @@ license: apache-2.0
 short_description: Financial analysis, investments, budget planning, and more.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# AI Financial Advisory Agent
+
+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.
+
+## 🚀 Features
+
+### Core Financial Tools
+- **📊 Investment Analyzer**: Real-time stock analysis with technical indicators, risk assessment, and investment recommendations
+- **💰 Budget Planner**: Personalized budget creation using the 50/30/20 rule with optimization suggestions
+- **💳 Expense Tracker**: Advanced expense analysis with trends, predictions, and anomaly detection
+- **📈 Portfolio Analyzer**: Portfolio diversification analysis and performance optimization
+- **📰 Market Trends Analyzer**: Real-time market news, sector analysis, and economic insights
+
+### Advanced Features
+- **🎯 Smart Response Type Detection**: Automatically detects if users want short summaries or detailed reports
+- **⚡ Real-time LLM Streaming**: Live token-by-token response generation from OpenAI API
+- **📋 Interactive Tool Results**: Collapsible sections for clean data presentation
+- **🔍 Comprehensive Data Analysis**: Enhanced visualizations and insights for all financial data
+- **⏱️ Real-time Status Updates**: Shows which APIs are being called and estimated completion times
+
+## 🛠️ Installation
+
+1. **Clone the repository**
+```bash
+git clone https://github.com/yourusername/financial-advisory-agent.git
+cd financial-advisory-agent
+```
+
+2. **Install dependencies**
+```bash
+pip install -r requirements.txt
+```
+
+3. **Set up environment variables**
+Create a `.env` file or set environment variables:
+```bash
+export OPENAI_API_KEY="your-openai-api-key"
+export TAVILY_API_KEY="your-tavily-api-key"
+```
+
+4. **Run the application**
+```bash
+python app.py
+```
+
+## 💬 Example Prompts
+
+### Single Tool Invocation
+
+#### Investment Analyzer
+```
+"Analyze AAPL stock and tell me if it's a good investment"
+"Should I buy Tesla stock right now?"
+"Give me a detailed analysis of Microsoft shares"
+"Quick summary of NVDA stock performance"
+```
+
+#### Budget Planner
+```
+"Help me create a budget with $5000 monthly income and expenses: rent $1500, food $500, utilities $200"
+"I make $75,000 annually, help me budget my expenses"
+"Create a budget plan for someone earning $4000/month"
+"Quick budget advice for $6000 monthly income"
+```
+
+#### Market Trends Analyzer
+```
+"What are the latest market trends in tech stocks?"
+"Give me current market news and analysis"
+"Detailed report on today's market movements"
+"Quick market update for technology sector"
+```
+
+#### Portfolio Analyzer
+```
+"Analyze my portfolio: {'holdings': [{'symbol': 'AAPL', 'shares': 100}, {'symbol': 'GOOGL', 'shares': 50}]}"
+"Check my diversification with holdings: AAPL 40%, MSFT 30%, TSLA 30%"
+"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)
+```
+"Quick analysis of AAPL"
+"Brief summary of market trends"
+"Give me a short budget recommendation"
+"Simple portfolio check"
+"Fast expense analysis"
+```
+
+#### Detailed Responses (Comprehensive reports)
+```
+"Give me a detailed report on AAPL stock"
+"Comprehensive market analysis for tech sector"
+"Thorough budget breakdown with recommendations"
+"In-depth portfolio diversification analysis"
+"Complete expense tracking report with insights"
+```
+
+### Multi-Tool Queries
+```
+"Analyze AAPL stock and create a budget for investing $1000 monthly"
+"What are the current market trends and how should I adjust my portfolio?"
+"Help me budget $5000 income and recommend some good stocks to invest in"
+"Track my expenses and suggest a better budget allocation"
+```
+
+### Advanced Queries
+```
+"I have $50K to invest. Analyze current market trends, suggest a diversified portfolio, and create a budget for monthly investments of $2000"
+"Detailed analysis: Review AAPL, MSFT, and GOOGL stocks, then help me rebalance my portfolio"
+"Comprehensive financial review: Budget analysis for $8000 monthly income, expense tracking, and investment recommendations"
+```
+
+## 🎯 Response Types
+
+The system automatically detects your preference:
+
+### Short Response Keywords
+- `quick`, `brief`, `short`, `summary`, `concise`, `simple`, `fast`, `tldr`, `bottom line`
+
+### Detailed Response Keywords  
+- `detailed`, `comprehensive`, `thorough`, `in-depth`, `report`, `breakdown`, `explain`, `elaborate`, `deep dive`
+
+### Default Behavior
+- **Short responses** are the default (under 200 words)
+- **Detailed responses** are triggered by specific keywords (comprehensive analysis)
+
+## 🔧 Technical Architecture
+
+- **Frontend**: Gradio web interface with real-time streaming
+- **Backend**: LangChain agents with OpenAI GPT-4
+- **Data Sources**: 
+  - Yahoo Finance API for stock data
+  - Tavily Search API for market news
+  - Real-time financial calculations
+- **Streaming**: Direct LLM token streaming from OpenAI API
+- **Tools**: Specialized financial analysis functions
+
+## 📊 Tool Capabilities
+
+### Investment Analyzer
+- Real-time stock prices and historical data
+- Technical indicators (RSI, MACD, Bollinger Bands, Moving Averages)
+- Risk assessment (volatility, VaR, beta analysis)
+- Fundamental analysis (P/E, P/B ratios, dividend yield)
+- Buy/Hold/Sell recommendations with confidence scores
+
+### Budget Planner
+- 50/30/20 rule implementation
+- Emergency fund calculations
+- Debt-to-income ratio analysis
+- Savings optimization recommendations
+- Expense category warnings
+
+### Market Trends Analyzer
+- Real-time market news via Tavily Search
+- Major index tracking (S&P 500, NASDAQ)
+- Market sentiment analysis
+- Key theme extraction
+- Economic trend identification
+
+### Portfolio Analyzer
+- Diversification scoring
+- Sector allocation analysis
+- Concentration risk assessment
+- Rebalancing recommendations
+- Performance metrics
+
+### Expense Tracker
+- Category-wise spending analysis
+- Trend detection and predictions
+- Budget vs. actual comparisons
+- Anomaly detection
+- Spending pattern insights
+
+## 🚀 Recent Updates
+
+- ✅ **Smart Response Detection**: Automatically detects if users want short or detailed responses
+- ✅ **Real LLM Streaming**: Genuine token-by-token streaming from OpenAI API
+- ✅ **Enhanced Tool Status**: Real-time API call tracking with time estimates
+- ✅ **Improved Data Analysis**: Comprehensive visualizations and insights
+- ✅ **Optimized Performance**: Faster tool execution and response times
+- ✅ **Collapsible Results**: Clean, organized tool output presentation
+
+## 🔒 API Keys Required
+
+- **OpenAI API Key**: For language model
+- **Tavily API Key**: For real-time market news and trends
+
+## Issues to Resolve
+The problem is in the current flow:
+    1. Agent executor runs all tools
+    2. We collect ALL results
+    3. Then display everything at once
+    4. Then stream the final response
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+

agents/financial_agent.py

@@ -0,0 +1,263 @@
+import json
+import operator
+import re
+from typing import Annotated, List, Tuple, TypedDict, Union
+
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.schema import AIMessage, HumanMessage, SystemMessage
+from langchain.tools import Tool
+from langchain_openai import ChatOpenAI
+
+
+class AgentState(TypedDict):
+    messages: Annotated[List[Union[HumanMessage, AIMessage]], operator.add]
+    context: dict
+
+
+class FinancialAdvisorAgent:
+    def __init__(self, tools: List[Tool], openai_api_key: str):
+        self.tools = tools
+        self.llm = ChatOpenAI(
+            api_key=openai_api_key, model="gpt-4.1-mini-2025-04-14", temperature=0.7
+        )
+        self.tools_by_name = {tool.name: tool for tool in tools}
+
+        # Create agent with tools
+        self.system_prompt = """You are a professional financial advisor AI assistant with access to specialized tools.
+
+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.
+
+IMPORTANT: You MUST use these tools when answering financial questions. Do not provide generic advice without using the appropriate tool first.
+
+When a user asks a question:
+1. Identify which tool is most appropriate
+2. Extract or request the necessary information
+3. Use the tool to get specific data
+4. Provide advice based on the tool's output"""
+
+        self.prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", self.system_prompt),
+                MessagesPlaceholder(variable_name="messages"),
+                ("human", "{input}"),
+                MessagesPlaceholder(variable_name="agent_scratchpad"),
+            ]
+        )
+
+        self.agent = create_openai_tools_agent(self.llm, self.tools, self.prompt)
+        self.agent_executor = AgentExecutor(
+            agent=self.agent,
+            tools=self.tools,
+            verbose=True,
+            return_intermediate_steps=True,
+        )
+
+    def _extract_tool_usage(self, intermediate_steps):
+        """Extract tool usage from intermediate steps"""
+        tools_used = []
+        tool_results = []
+
+        for action, result in intermediate_steps:
+            if hasattr(action, "tool"):
+                tools_used.append(action.tool)
+                tool_results.append(result)
+
+        # Return the last tool used and its result for backward compatibility
+        # But also return all tools and results for multi-tool scenarios
+        if tools_used:
+            return tools_used[-1], tool_results[-1], tools_used, tool_results
+        return None, None, [], []
+
+    def _prepare_tool_input(self, message: str, tool_name: str) -> str:
+        """Prepare input for specific tools based on the message"""
+        if tool_name == "investment_analyzer":
+            # Extract stock symbols
+            symbols = re.findall(r"\b[A-Z]{2,5}\b", message)
+            if symbols:
+                return symbols[0]
+            return "AAPL"  # Default
+
+        elif tool_name == "budget_planner":
+            # Try to extract income and expenses from message
+            income_match = re.search(
+                r"\$?(\d+(?:,\d{3})*(?:\.\d{2})?)\s*(?:monthly\s*)?income",
+                message,
+                re.I,
+            )
+            income = (
+                float(income_match.group(1).replace(",", "")) if income_match else 5000
+            )
+
+            # Extract expenses
+            expenses = {}
+            expense_patterns = [
+                (r"rent:?\s*\$?(\d+(?:,\d{3})*(?:\.\d{2})?)", "rent"),
+                (r"food:?\s*\$?(\d+(?:,\d{3})*(?:\.\d{2})?)", "food"),
+                (r"utilities:?\s*\$?(\d+(?:,\d{3})*(?:\.\d{2})?)", "utilities"),
+                (
+                    r"transportation:?\s*\$?(\d+(?:,\d{3})*(?:\.\d{2})?)",
+                    "transportation",
+                ),
+            ]
+
+            for pattern, category in expense_patterns:
+                match = re.search(pattern, message, re.I)
+                if match:
+                    expenses[category] = float(match.group(1).replace(",", ""))
+
+            return json.dumps({"income": income, "expenses": expenses})
+
+        elif tool_name == "portfolio_analyzer":
+            # Try to extract portfolio data
+            if "holdings" in message:
+                return message  # Assume it's already formatted
+            return json.dumps({"holdings": [{"symbol": "AAPL", "shares": 100}]})
+
+        elif tool_name == "market_trends":
+            return message
+
+        return message
+
+    def process_message_with_details(
+        self, message: str, history: List[dict] = None
+    ) -> Tuple[str, str, str, List[str], List[str]]:
+        """Process a message and return response, tool used, tool result, and all tools/results"""
+        if history is None:
+            history = []
+
+        # 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"],
+            "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"]
+        }
+        
+        detected_tools = []
+        for tool_name, keywords in tool_keywords.items():
+            if any(word in message_lower for word in keywords):
+                # Special check for investment analyzer - needs stock symbols
+                if tool_name == "investment_analyzer":
+                    if re.search(r"\b[A-Z]{2,5}\b", message) or any(word in message_lower for word in ["stock", "invest", "recommend"]):
+                        detected_tools.append(tool_name)
+                else:
+                    detected_tools.append(tool_name)
+        
+        # If multiple tools detected or complex query, use agent executor
+        if len(detected_tools) > 1 or len(message.split()) > 15:
+            try:
+                result = self.agent_executor.invoke({"input": message, "messages": []})
+
+                tool_used, tool_result, all_tools, all_results = self._extract_tool_usage(
+                    result.get("intermediate_steps", [])
+                )
+                return result["output"], tool_used, tool_result, all_tools, all_results
+
+            except Exception as e:
+                return (
+                    f"I encountered an error processing your request: {str(e)}",
+                    None,
+                    None,
+                    [],
+                    []
+                )
+        
+        # Single tool execution for simple queries
+        elif len(detected_tools) == 1:
+            selected_tool = detected_tools[0]
+            try:
+                tool = self.tools_by_name[selected_tool]
+                tool_input = self._prepare_tool_input(message, selected_tool)
+                
+                # Execute the tool
+                tool_result = tool.func(tool_input)
+
+                # Generate response based on tool result - optimized for speed
+                response_prompt = f"""Based on this {selected_tool.replace('_', ' ')} analysis, provide a concise financial summary for: {message}
+
+Data: {tool_result}
+
+Keep response under 200 words with key insights and 2-3 actionable recommendations."""
+
+                response = self.llm.invoke(
+                    [
+                        SystemMessage(content="Financial advisor. Be concise and actionable."),
+                        HumanMessage(content=response_prompt),
+                    ]
+                )
+
+                return response.content, selected_tool, tool_result, [selected_tool], [tool_result]
+
+            except Exception as e:
+                return f"Error using {selected_tool}: {str(e)}", selected_tool, None, [], []
+
+        # Fallback to agent executor for unclear queries
+        else:
+            try:
+                result = self.agent_executor.invoke({"input": message, "messages": []})
+
+                tool_used, tool_result, all_tools, all_results = self._extract_tool_usage(
+                    result.get("intermediate_steps", [])
+                )
+                return result["output"], tool_used, tool_result, all_tools, all_results
+
+            except Exception as e:
+                return (
+                    f"I encountered an error processing your request: {str(e)}",
+                    None,
+                    None,
+                    [],
+                    []
+                )
+
+    def process_message(self, message: str, history: List[dict] = None):
+        """Process a user message and return response"""
+        response, _, _, _, _ = self.process_message_with_details(message, history)
+        return response
+    
+    def stream_response(self, message: str, tool_result: str, selected_tool: str, response_type: str = "short"):
+        """Stream the LLM response in real-time"""
+        
+        if response_type == "detailed":
+            response_prompt = f"""Based on the following comprehensive analysis from the {selected_tool.replace('_', ' ').title()}:
+
+{tool_result}
+
+Provide detailed financial advice to the user addressing their question: {message}
+
+Guidelines:
+- Be thorough and comprehensive
+- Reference specific data points from the analysis
+- Provide clear, actionable recommendations with explanations
+- Include multiple scenarios or considerations where relevant
+- Use a professional but friendly tone
+- Structure your response with clear sections
+- Provide context for your recommendations"""
+
+            system_message = "You are a professional financial advisor. Provide comprehensive, detailed advice based on the analysis results. Be thorough and educational."
+        else:
+            response_prompt = f"""Based on this {selected_tool.replace('_', ' ')} analysis, provide a concise financial summary for: {message}
+
+Data: {tool_result}
+
+Keep response under 200 words with key insights and 2-3 actionable recommendations."""
+
+            system_message = "Financial advisor. Be concise and actionable."
+
+        messages = [
+            SystemMessage(content=system_message),
+            HumanMessage(content=response_prompt),
+        ]
+        
+        # Stream the response token by token
+        for chunk in self.llm.stream(messages):
+            if chunk.content:
+                yield chunk.content

agents/tools.py

@@ -0,0 +1,696 @@
+import json
+from datetime import datetime, timedelta
+from typing import List, Dict, Any
+
+import pandas as pd
+import yfinance as yf
+from langchain.tools import Tool
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+
+class FinancialTools:
+    def __init__(self, tavily_api_key: str):
+        self.tavily_search = TavilySearchResults(api_key=tavily_api_key)
+
+    def create_budget_planner(self) -> Tool:
+        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)
+                expenses = data.get("expenses", {})
+                goals = data.get("savings_goals", {})
+                debt = data.get("debt", {})
+
+                # Calculate budget allocations using 50/30/20 rule
+                needs = income * 0.5
+                wants = income * 0.3
+                savings = income * 0.2
+
+                total_expenses = sum(expenses.values())
+                remaining = income - total_expenses
+
+                # Debt analysis
+                total_debt = sum(debt.values()) if debt else 0
+                debt_to_income = (total_debt / income * 100) if income > 0 else 0
+
+                # Emergency fund calculation (3-6 months of expenses)
+                emergency_fund_needed = total_expenses * 6
+                emergency_fund_goal = goals.get("emergency_fund", 0)
+
+                # Calculate actual savings potential
+                debt_payments = debt.get("monthly_payments", 0)
+                available_for_savings = remaining - debt_payments
+
+                budget_plan = {
+                    "monthly_income": income,
+                    "recommended_allocation": {
+                        "needs": needs,
+                        "wants": wants,
+                        "savings": savings,
+                    },
+                    "current_expenses": expenses,
+                    "total_expenses": total_expenses,
+                    "remaining_budget": remaining,
+                    "savings_rate": (available_for_savings / income * 100) if income > 0 else 0,
+                    "debt_analysis": {
+                        "total_debt": total_debt,
+                        "debt_to_income_ratio": debt_to_income,
+                        "monthly_payments": debt_payments,
+                    },
+                    "emergency_fund": {
+                        "recommended": emergency_fund_needed,
+                        "current": emergency_fund_goal,
+                        "progress": (emergency_fund_goal / emergency_fund_needed * 100) if emergency_fund_needed > 0 else 0,
+                    },
+                    "savings_optimization": {
+                        "available_monthly": available_for_savings,
+                        "annual_savings_potential": available_for_savings * 12,
+                    },
+                    "recommendations": [],
+                }
+
+                # Enhanced recommendations
+                if available_for_savings < savings:
+                    budget_plan["recommendations"].append(
+                        f"Increase savings by ${savings - available_for_savings:.2f}/month to reach 20% goal"
+                    )
+
+                if debt_to_income > 36:
+                    budget_plan["recommendations"].append(
+                        f"High debt-to-income ratio ({debt_to_income:.1f}%). Consider debt consolidation."
+                    )
+
+                if emergency_fund_goal < emergency_fund_needed:
+                    monthly_needed = (emergency_fund_needed - emergency_fund_goal) / 12
+                    budget_plan["recommendations"].append(
+                        f"Build emergency fund: save ${monthly_needed:.2f}/month for 12 months"
+                    )
+
+                # Expense optimization suggestions
+                largest_expense = max(expenses.items(), key=lambda x: x[1]) if expenses else None
+                if largest_expense and largest_expense[1] > income * 0.35:
+                    budget_plan["recommendations"].append(
+                        f"Your {largest_expense[0]} expense (${largest_expense[1]:.2f}) is high. Consider cost reduction."
+                    )
+
+                return json.dumps(budget_plan, indent=2)
+            except Exception as e:
+                return f"Error creating budget plan: {str(e)}"
+
+        return Tool(
+            name="budget_planner",
+            description="Create personalized budget plans with income and expense analysis",
+            func=budget_planner,
+        )
+
+    def create_investment_analyzer(self) -> Tool:
+        def investment_analyzer(symbol: str) -> str:
+            """Analyze stocks with advanced metrics, sector comparison, and risk assessment"""
+            try:
+                stock = yf.Ticker(symbol.upper())
+                info = stock.info
+                hist = stock.history(period="1y")  # Reduced from 2y to 1y for speed
+
+                if hist.empty:
+                    return f"No data available for {symbol}"
+
+                # Calculate key metrics
+                current_price = info.get("currentPrice", hist["Close"].iloc[-1])
+                pe_ratio = info.get("trailingPE", "N/A")
+                pb_ratio = info.get("priceToBook", "N/A")
+                dividend_yield = (info.get("dividendYield", 0) * 100 if info.get("dividendYield") else 0)
+                market_cap = info.get("marketCap", "N/A")
+                beta = info.get("beta", "N/A")
+                sector = info.get("sector", "Unknown")
+                industry = info.get("industry", "Unknown")
+
+                # Advanced technical indicators
+                sma_20 = hist["Close"].rolling(window=20).mean().iloc[-1]
+                sma_50 = hist["Close"].rolling(window=50).mean().iloc[-1] if len(hist) >= 50 else None
+                sma_200 = hist["Close"].rolling(window=200).mean().iloc[-1] if len(hist) >= 200 else None
+                
+                # RSI calculation
+                delta = hist["Close"].diff()
+                gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+                loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+                rs = gain / loss
+                rsi = 100 - (100 / (1 + rs)).iloc[-1]
+
+                # Simplified MACD calculation
+                ema_12 = hist["Close"].ewm(span=12).mean()
+                ema_26 = hist["Close"].ewm(span=26).mean()
+                macd = ema_12 - ema_26
+                macd_signal = macd.ewm(span=9).mean()
+
+                # Simplified Bollinger Bands (only what we need)
+                bb_middle = hist["Close"].rolling(window=20).mean()
+                bb_std_dev = hist["Close"].rolling(window=20).std()
+                bb_upper = bb_middle + (bb_std_dev * 2)
+                bb_lower = bb_middle - (bb_std_dev * 2)
+
+                # Simplified volatility analysis
+                volatility_30d = hist["Close"].pct_change().rolling(30).std().iloc[-1] * 100
+                
+                # Value at Risk (VaR) - 5% level
+                returns = hist["Close"].pct_change().dropna()
+                var_5 = returns.quantile(0.05) * 100
+
+                # Performance metrics
+                price_1m = hist["Close"].iloc[-22] if len(hist) >= 22 else None
+                price_3m = hist["Close"].iloc[-66] if len(hist) >= 66 else None
+                price_6m = hist["Close"].iloc[-132] if len(hist) >= 132 else None
+                price_1y = hist["Close"].iloc[-252] if len(hist) >= 252 else None
+
+                performance = {}
+                if price_1m: performance["1_month"] = ((current_price - price_1m) / price_1m * 100)
+                if price_3m: performance["3_month"] = ((current_price - price_3m) / price_3m * 100)
+                if price_6m: performance["6_month"] = ((current_price - price_6m) / price_6m * 100)
+                if price_1y: performance["1_year"] = ((current_price - price_1y) / price_1y * 100)
+
+                # Sharpe ratio calculation (using risk-free rate of 4%)
+                risk_free_rate = 0.04
+                mean_return = returns.mean() * 252
+                return_std = returns.std() * (252**0.5)
+                sharpe_ratio = (mean_return - risk_free_rate) / return_std if return_std > 0 else 0
+
+                # Risk assessment
+                risk_score = 0
+                risk_factors = []
+                
+                if volatility_30d > 30:
+                    risk_score += 2
+                    risk_factors.append("High volatility (>30%)")
+                elif volatility_30d > 20:
+                    risk_score += 1
+                    risk_factors.append("Moderate volatility (20-30%)")
+
+                if isinstance(beta, (int, float)):
+                    if beta > 1.5:
+                        risk_score += 2
+                        risk_factors.append(f"High beta ({beta:.2f}) - market sensitive")
+                    elif beta > 1.2:
+                        risk_score += 1
+                        risk_factors.append(f"Above-average beta ({beta:.2f})")
+
+                if var_5 < -5:
+                    risk_score += 2
+                    risk_factors.append(f"High downside risk (VaR: {var_5:.1f}%)")
+
+                # Enhanced recommendation logic
+                recommendation = "HOLD"
+                confidence = 50
+                reasoning = []
+
+                # Technical analysis
+                if current_price < bb_lower.iloc[-1]:
+                    recommendation = "BUY"
+                    confidence += 20
+                    reasoning.append("Price below Bollinger Band lower bound (oversold)")
+                elif current_price > bb_upper.iloc[-1]:
+                    recommendation = "SELL"
+                    confidence += 15
+                    reasoning.append("Price above Bollinger Band upper bound (overbought)")
+
+                # RSI analysis
+                if rsi < 30:
+                    if recommendation != "SELL":
+                        recommendation = "BUY"
+                    confidence += 15
+                    reasoning.append(f"RSI oversold ({rsi:.1f})")
+                elif rsi > 70:
+                    if recommendation != "BUY":
+                        recommendation = "SELL"
+                    confidence += 10
+                    reasoning.append(f"RSI overbought ({rsi:.1f})")
+
+                # MACD analysis
+                if macd.iloc[-1] > macd_signal.iloc[-1] and macd.iloc[-2] <= macd_signal.iloc[-2]:
+                    if recommendation != "SELL":
+                        recommendation = "BUY"
+                    confidence += 10
+                    reasoning.append("MACD bullish crossover")
+
+                # Fundamental analysis
+                if isinstance(pe_ratio, (int, float)):
+                    if pe_ratio < 15:
+                        confidence += 10
+                        reasoning.append("Low P/E ratio suggests undervaluation")
+                    elif pe_ratio > 30:
+                        confidence -= 5
+                        reasoning.append("High P/E ratio suggests overvaluation")
+
+                # Risk adjustment
+                if risk_score >= 4:
+                    if recommendation == "BUY":
+                        recommendation = "HOLD"
+                    confidence -= 15
+                    reasoning.append("High risk profile suggests caution")
+
+                analysis = {
+                    "symbol": symbol.upper(),
+                    "company_name": info.get("longName", symbol),
+                    "sector": sector,
+                    "industry": industry,
+                    "current_price": f"${current_price:.2f}",
+                    "market_cap": f"${market_cap:,.0f}" if isinstance(market_cap, (int, float)) else "N/A",
+                    "fundamental_metrics": {
+                        "pe_ratio": pe_ratio,
+                        "pb_ratio": pb_ratio,
+                        "dividend_yield": f"{dividend_yield:.2f}%",
+                        "beta": beta,
+                        "sharpe_ratio": f"{sharpe_ratio:.2f}",
+                    },
+                    "technical_indicators": {
+                        "sma_20": f"${sma_20:.2f}",
+                        "sma_50": f"${sma_50:.2f}" if sma_50 else "N/A",
+                        "sma_200": f"${sma_200:.2f}" if sma_200 else "N/A",
+                        "rsi": f"{rsi:.1f}",
+                        "macd": f"{macd.iloc[-1]:.2f}",
+                        "bollinger_position": "Lower" if current_price < bb_lower.iloc[-1] else "Upper" if current_price > bb_upper.iloc[-1] else "Middle",
+                    },
+                    "risk_assessment": {
+                        "volatility_30d": f"{volatility_30d:.1f}%",
+                        "value_at_risk_5%": f"{var_5:.1f}%",
+                        "risk_score": f"{risk_score}/6",
+                        "risk_factors": risk_factors,
+                        "risk_level": "Low" if risk_score <= 1 else "Medium" if risk_score <= 3 else "High",
+                    },
+                    "price_levels": {
+                        "52_week_high": f"${info.get('fiftyTwoWeekHigh', 'N/A')}",
+                        "52_week_low": f"${info.get('fiftyTwoWeekLow', 'N/A')}",
+                    },
+                    "performance": {k: f"{v:.1f}%" for k, v in performance.items()},
+                    "recommendation": {
+                        "action": recommendation,
+                        "confidence": f"{min(max(confidence, 20), 95)}%",
+                        "reasoning": reasoning,
+                        "target_allocation": "5-10%" if recommendation == "BUY" else "0-5%" if recommendation == "SELL" else "3-7%",
+                    },
+                    "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                }
+
+                return json.dumps(analysis, indent=2)
+            except Exception as e:
+                return f"Error analyzing {symbol}: {str(e)}"
+
+        return Tool(
+            name="investment_analyzer",
+            description="Analyze stocks and provide investment recommendations",
+            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:
+            """Get comprehensive real-time market trends, news, and sector analysis"""
+            try:
+                # Get current year for search queries
+                current_year = datetime.now().year
+                
+                # Status tracking for API calls
+                status_updates = []
+                
+                # Optimized single comprehensive search instead of multiple calls
+                comprehensive_query = f"stock market {query} trends analysis financial news {current_year} latest"
+                
+                # Get primary market information
+                status_updates.append("🔍 Fetching latest market news via Tavily Search API...")
+                market_news = self.tavily_search.run(comprehensive_query)
+                status_updates.append("✅ Market news retrieved successfully")
+                
+                # Quick market indices check (reduced to just S&P 500 and NASDAQ for speed)
+                index_data = {}
+                market_sentiment = {"overall": "Unknown", "note": "Limited data"}
+                
+                try:
+                    status_updates.append("📊 Fetching market indices via Yahoo Finance API...")
+                    # Fetch only key indices for speed
+                    key_indices = ["^GSPC", "^IXIC"]  # S&P 500, NASDAQ
+                    
+                    for index in key_indices:
+                        index_names = {"^GSPC": "S&P 500", "^IXIC": "NASDAQ"}
+                        status_updates.append(f"📈 Getting {index_names[index]} data...")
+                        
+                        ticker = yf.Ticker(index)
+                        hist = ticker.history(period="2d")  # Reduced period for speed
+                        if not hist.empty:
+                            current = hist["Close"].iloc[-1]
+                            prev = hist["Close"].iloc[-2] if len(hist) > 1 else current
+                            change = ((current - prev) / prev * 100) if prev != 0 else 0
+                            
+                            index_data[index_names[index]] = {
+                                "current": round(current, 2),
+                                "change_pct": round(change, 2),
+                                "direction": "📈" if change > 0 else "📉" if change < 0 else "➡️"
+                            }
+                    
+                    status_updates.append("✅ Market indices data retrieved successfully")
+                    
+                    # Simple sentiment based on available indices
+                    if index_data:
+                        status_updates.append("🧠 Analyzing market sentiment...")
+                        positive_count = sum(1 for data in index_data.values() if data["change_pct"] > 0)
+                        total_count = len(index_data)
+                        
+                        if positive_count >= total_count * 0.75:
+                            sentiment = "🟢 Bullish"
+                        elif positive_count <= total_count * 0.25:
+                            sentiment = "🔴 Bearish"
+                        else:
+                            sentiment = "🟡 Mixed"
+                        
+                        market_sentiment = {
+                            "overall": sentiment,
+                            "summary": f"{positive_count}/{total_count} indices positive"
+                        }
+                        status_updates.append("✅ Market sentiment analysis completed")
+                        
+                except Exception as index_error:
+                    status_updates.append(f"❌ Error fetching market indices: {str(index_error)}")
+                    index_data = {"error": f"Index data unavailable: {str(index_error)}"}
+                
+                # Extract key themes from search results
+                status_updates.append("🔍 Analyzing key market themes...")
+                key_themes = _extract_key_themes(market_news)
+                status_updates.append("✅ Theme analysis completed")
+                
+                # Format output for better readability
+                def format_search_results(results):
+                    """Convert search results to readable format"""
+                    if isinstance(results, list):
+                        # Extract key information from search results
+                        formatted = []
+                        for item in results[:3]:  # Limit to top 3 results
+                            if isinstance(item, dict):
+                                title = item.get('title', 'No title')
+                                content = item.get('content', item.get('snippet', 'No content'))
+                                formatted.append(f"• {title}: {content[:200]}...")
+                            else:
+                                formatted.append(f"• {str(item)[:200]}...")
+                        return "\n".join(formatted)
+                    elif isinstance(results, str):
+                        return results[:1000] + "..." if len(results) > 1000 else results
+                    else:
+                        return str(results)[:1000]
+                
+                status_updates.append("📋 Compiling final analysis report...")
+                
+                # Compile streamlined analysis
+                analysis = {
+                    "query": query,
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    "api_execution_log": status_updates,
+                    "market_summary": format_search_results(market_news),
+                    "key_indices": index_data,
+                    "market_sentiment": market_sentiment,
+                    "key_themes": key_themes,
+                    "note": "Real-time API status tracking enabled"
+                }
+                
+                status_updates.append("✅ Analysis report completed successfully")
+                
+                return json.dumps(analysis, indent=2, ensure_ascii=False)
+                
+            except Exception as e:
+                return f"Error fetching market analysis: {str(e)}"
+        
+        def _extract_key_themes(news_text) -> list:
+            """Extract key themes from market news"""
+            themes = []
+            keywords = {
+                "earnings": ["earnings", "quarterly results", "revenue", "profit"],
+                "fed_policy": ["federal reserve", "interest rates", "fed", "monetary policy"],
+                "inflation": ["inflation", "cpi", "price increases", "cost of living"],
+                "geopolitical": ["geopolitical", "war", "trade war", "sanctions"],
+                "technology": ["ai", "artificial intelligence", "tech stocks", "innovation"],
+                "recession": ["recession", "economic downturn", "market crash"],
+            }
+            
+            # Handle both string and list inputs
+            if isinstance(news_text, list):
+                # Convert list to string
+                news_text = " ".join(str(item) for item in news_text)
+            elif not isinstance(news_text, str):
+                # Convert other types to string
+                news_text = str(news_text)
+            
+            news_lower = news_text.lower()
+            for theme, terms in keywords.items():
+                if any(term in news_lower for term in terms):
+                    themes.append(theme.replace("_", " ").title())
+            
+            return themes[:5]  # Return top 5 themes
+
+        return Tool(
+            name="market_trends",
+            description="Get real-time market trends and financial news",
+            func=market_trends,
+        )
+
+    def create_portfolio_analyzer(self) -> Tool:
+        def portfolio_analyzer(input_str: str) -> str:
+            """Analyze portfolio performance and diversification"""
+            try:
+                data = json.loads(input_str)
+                holdings = data.get("holdings", [])
+
+                total_value = 0
+                portfolio_data = []
+
+                for holding in holdings:
+                    symbol = holding["symbol"]
+                    shares = holding["shares"]
+
+                    stock = yf.Ticker(symbol)
+                    current_price = stock.info.get("currentPrice", 0)
+                    value = current_price * shares
+                    total_value += value
+
+                    portfolio_data.append(
+                        {
+                            "symbol": symbol,
+                            "shares": shares,
+                            "current_price": current_price,
+                            "value": value,
+                            "sector": stock.info.get("sector", "Unknown"),
+                        }
+                    )
+
+                # 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)
+                sector_allocation = df.groupby("sector")["allocation"].sum().to_dict()
+
+                analysis = {
+                    "total_portfolio_value": f"${total_value:.2f}",
+                    "holdings": portfolio_data,
+                    "sector_allocation": sector_allocation,
+                    "diversification_score": len(sector_allocation)
+                    / 11
+                    * 100,  # 11 major sectors
+                    "recommendations": [],
+                }
+
+                # Add recommendations
+                if len(holdings) < 5:
+                    analysis["recommendations"].append(
+                        "Consider diversifying with more holdings"
+                    )
+
+                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}%"
+                    )
+
+                return json.dumps(analysis, indent=2)
+
+            except Exception as e:
+                return f"Error analyzing portfolio: {str(e)}"
+
+        return Tool(
+            name="portfolio_analyzer",
+            description="Analyze portfolio performance and diversification",
+            func=portfolio_analyzer,
+        )
+
+    def get_all_tools(self) -> List[Tool]:
+        return [
+            self.create_budget_planner(),
+            self.create_investment_analyzer(),
+            self.create_expense_tracker(),
+            self.create_market_trends_analyzer(),
+            self.create_portfolio_analyzer(),
+        ]

app.py

@@ -0,0 +1,747 @@
+import json
+import os
+import time
+from pathlib import Path
+
+import gradio as gr
+from gradio import ChatMessage
+
+from agents.financial_agent import FinancialAdvisorAgent
+from agents.tools import FinancialTools
+
+# Avatar configuration
+AVATAR_IMAGES = (
+    None,
+    "./public/images/fin_logo.png",
+)
+
+# Initialize tools and agent
+financial_tools = FinancialTools(tavily_api_key=os.getenv("TAVILY_API_KEY"))
+tools = financial_tools.get_all_tools()
+
+agent = FinancialAdvisorAgent(tools=tools, openai_api_key=os.getenv("OPENAI_API_KEY"))
+
+gr.set_static_paths(paths=[(Path.cwd() / "public" / "images").absolute()])
+
+
+def analyze_data_with_repl(data_type, data):
+    """Analyze financial data using Python REPL with comprehensive insights"""
+
+    if data_type == "budget":
+        try:
+            budget_data = json.loads(data)
+            categories = list(budget_data.get("current_expenses", {}).keys())
+            values = list(budget_data.get("current_expenses", {}).values())
+            income = budget_data.get("monthly_income", budget_data.get("income", 0))
+
+            if categories and values:
+                total_expenses = sum(values)
+                analysis_text = "💰 **Comprehensive Budget Analysis**\n\n"
+                
+                # Income vs Expenses Overview
+                analysis_text += "## 📈 **Income vs Expenses Overview**\n"
+                analysis_text += f"- **Monthly Income**: ${income:,.0f}\n"
+                analysis_text += f"- **Total Expenses**: ${total_expenses:,.0f}\n"
+                
+                if income > 0:
+                    remaining = income - total_expenses
+                    savings_rate = (remaining / income * 100) if income > 0 else 0
+                    
+                    if remaining > 0:
+                        analysis_text += f"- **💚 Surplus**: ${remaining:,.0f}\n"
+                        analysis_text += f"- **💎 Savings Rate**: {savings_rate:.1f}%\n"
+                    else:
+                        analysis_text += f"- **🔴 Deficit**: ${abs(remaining):,.0f}\n"
+                        analysis_text += f"- **⚠️ Overspending**: {abs(savings_rate):.1f}%\n"
+                
+                # Expense Breakdown with Progress Bars
+                analysis_text += "\n## 💳 **Expense Breakdown**\n"
+                for i, (category, amount) in enumerate(zip(categories, values)):
+                    percentage = (amount / total_expenses * 100) if total_expenses > 0 else 0
+                    income_percentage = (amount / income * 100) if income > 0 else 0
+                    bar = "█" * min(int(percentage / 3), 30)  # Max 30 chars
+                    
+                    analysis_text += f"**{category.title()}**: ${amount:,.0f}\n"
+                    analysis_text += f"  └─ {percentage:.1f}% of expenses | {income_percentage:.1f}% of income {bar}\n\n"
+                
+                # Financial Health Metrics
+                analysis_text += "## 📊 **Financial Health Metrics**\n"
+                avg_expense = total_expenses / len(values)
+                largest_expense = max(values)
+                smallest_expense = min(values)
+                largest_category = categories[values.index(largest_expense)]
+                smallest_category = categories[values.index(smallest_expense)]
+                
+                analysis_text += f"- **Average Category Expense**: ${avg_expense:,.0f}\n"
+                analysis_text += f"- **Highest Expense**: {largest_category} (${largest_expense:,.0f})\n"
+                analysis_text += f"- **Lowest Expense**: {smallest_category} (${smallest_expense:,.0f})\n"
+                analysis_text += f"- **Expense Range**: ${largest_expense - smallest_expense:,.0f}\n"
+                
+                # Budget Recommendations
+                analysis_text += "\n## 💡 **Smart Budget Insights**\n"
+                
+                # 50/30/20 Rule Analysis
+                if income > 0:
+                    needs_target = income * 0.50
+                    wants_target = income * 0.30
+                    savings_target = income * 0.20
+                    
+                    analysis_text += f"**50/30/20 Rule Comparison:**\n"
+                    analysis_text += f"- Needs Target (50%): ${needs_target:,.0f}\n"
+                    analysis_text += f"- Wants Target (30%): ${wants_target:,.0f}\n"
+                    analysis_text += f"- Savings Target (20%): ${savings_target:,.0f}\n"
+                    
+                    if savings_rate >= 20:
+                        analysis_text += "✅ **Excellent savings rate!**\n"
+                    elif savings_rate >= 10:
+                        analysis_text += "⚠️ **Good savings, aim for 20%**\n"
+                    else:
+                        analysis_text += "🔴 **Consider reducing expenses to save more**\n"
+                
+                # Category Warnings
+                for category, amount in zip(categories, values):
+                    if income > 0:
+                        cat_percentage = (amount / income * 100)
+                        if category.lower() in ['rent', 'housing'] and cat_percentage > 30:
+                            analysis_text += f"⚠️ **Housing costs high**: {cat_percentage:.1f}% (recommend <30%)\n"
+                        elif category.lower() in ['food', 'dining'] and cat_percentage > 15:
+                            analysis_text += f"⚠️ **Food costs high**: {cat_percentage:.1f}% (recommend <15%)\n"
+                
+                return analysis_text
+        except Exception as e:
+            return f"Error analyzing budget data: {str(e)}"
+
+    elif data_type == "portfolio":
+        try:
+            portfolio_data = json.loads(data)
+            holdings = portfolio_data.get("holdings", [])
+            total_value = sum(holding.get("value", 0) for holding in holdings)
+            
+            analysis_text = "📊 **Advanced Portfolio Analysis**\n\n"
+            
+            # Portfolio Overview
+            analysis_text += "## 💼 **Portfolio Overview**\n"
+            analysis_text += f"- **Total Portfolio Value**: ${total_value:,.2f}\n"
+            analysis_text += f"- **Number of Holdings**: {len(holdings)}\n"
+            
+            if holdings:
+                values = [holding.get("value", 0) for holding in holdings]
+                avg_holding = sum(values) / len(values)
+                max_holding = max(values)
+                min_holding = min(values)
+                
+                analysis_text += f"- **Average Holding Size**: ${avg_holding:,.2f}\n"
+                analysis_text += f"- **Largest Position**: ${max_holding:,.2f}\n"
+                analysis_text += f"- **Smallest Position**: ${min_holding:,.2f}\n"
+            
+            # Detailed Holdings breakdown
+            analysis_text += "\n## 📈 **Holdings Breakdown**\n"
+            sorted_holdings = sorted(holdings, key=lambda x: x.get("value", 0), reverse=True)
+            
+            for i, holding in enumerate(sorted_holdings, 1):
+                symbol = holding.get("symbol", "Unknown")
+                value = holding.get("value", 0)
+                shares = holding.get("shares", 0)
+                allocation = holding.get("allocation", (value/total_value*100) if total_value > 0 else 0)
+                sector = holding.get("sector", "Unknown")
+                
+                # Calculate position concentration risk
+                risk_level = "🟢 Low" if allocation < 10 else "🟡 Medium" if allocation < 25 else "🔴 High"
+                
+                analysis_text += f"**#{i} {symbol}** - {sector}\n"
+                analysis_text += f"  └─ Value: ${value:,.2f} | Shares: {shares:,.0f} | Weight: {allocation:.1f}%\n"
+                analysis_text += f"  └─ Concentration Risk: {risk_level}\n\n"
+            
+            # Sector analysis with advanced metrics
+            sectors = {}
+            sector_values = {}
+            for holding in holdings:
+                sector = holding.get("sector", "Unknown")
+                allocation = holding.get("allocation", 0)
+                value = holding.get("value", 0)
+                
+                sectors[sector] = sectors.get(sector, 0) + allocation
+                sector_values[sector] = sector_values.get(sector, 0) + value
+            
+            if sectors:
+                analysis_text += "## 🏭 **Sector Diversification Analysis**\n"
+                sorted_sectors = sorted(sectors.items(), key=lambda x: x[1], reverse=True)
+                
+                for sector, allocation in sorted_sectors:
+                    bar = "█" * min(int(allocation / 2), 30)
+                    value = sector_values.get(sector, 0)
+                    
+                    # Sector concentration assessment
+                    if allocation > 40:
+                        risk_emoji = "🔴"
+                        risk_text = "Over-concentrated"
+                    elif allocation > 25:
+                        risk_emoji = "🟡"
+                        risk_text = "Moderate concentration"
+                    else:
+                        risk_emoji = "🟢"
+                        risk_text = "Well diversified"
+                    
+                    analysis_text += f"**{sector}**: {allocation:.1f}% (${value:,.2f}) {risk_emoji}\n"
+                    analysis_text += f"  └─ {bar} {risk_text}\n\n"
+            
+            # Portfolio Health Metrics
+            analysis_text += "## 🎯 **Portfolio Health Assessment**\n"
+            
+            # Diversification Score
+            num_sectors = len(sectors)
+            if num_sectors >= 8:
+                diversification = "🟢 Excellent"
+            elif num_sectors >= 5:
+                diversification = "🟡 Good"
+            else:
+                diversification = "🔴 Poor"
+            
+            analysis_text += f"- **Sector Diversification**: {diversification} ({num_sectors} sectors)\n"
+            
+            # Concentration Risk
+            if holdings:
+                top_3_allocation = sum(sorted([h.get("allocation", 0) for h in holdings], reverse=True)[:3])
+                if top_3_allocation > 60:
+                    concentration_risk = "🔴 High"
+                elif top_3_allocation > 40:
+                    concentration_risk = "🟡 Medium"
+                else:
+                    concentration_risk = "🟢 Low"
+                
+                analysis_text += f"- **Concentration Risk**: {concentration_risk} (Top 3: {top_3_allocation:.1f}%)\n"
+            
+            # Portfolio Recommendations
+            analysis_text += "\n## 💡 **Portfolio Optimization Recommendations**\n"
+            
+            # Check for over-concentration
+            for holding in holdings:
+                allocation = holding.get("allocation", 0)
+                if allocation > 25:
+                    analysis_text += f"⚠️ **{holding.get('symbol', 'Unknown')}** is over-weighted at {allocation:.1f}% (consider rebalancing)\n"
+            
+            # Sector recommendations
+            for sector, allocation in sectors.items():
+                if allocation > 40:
+                    analysis_text += f"⚠️ **{sector}** sector over-weighted at {allocation:.1f}% (consider diversification)\n"
+            
+            # Diversification suggestions
+            if num_sectors < 5:
+                analysis_text += "💡 **Consider adding exposure to more sectors for better diversification**\n"
+            
+            if len(holdings) < 10:
+                analysis_text += "💡 **Consider adding more holdings to reduce single-stock risk**\n"
+            
+            return analysis_text
+        except Exception as e:
+            return f"Error analyzing portfolio data: {str(e)}"
+
+    elif data_type == "stock":
+        try:
+            stock_data = json.loads(data)
+            symbol = stock_data.get("symbol", "Unknown")
+            price_str = stock_data.get("current_price", "0")
+            
+            analysis_text = f"📈 **Comprehensive Stock Analysis: {symbol}**\n\n"
+            
+            # Company Overview
+            analysis_text += "## 🏢 **Company Overview**\n"
+            analysis_text += f"- **Symbol**: {symbol}\n"
+            analysis_text += f"- **Current Price**: {price_str}\n"
+            analysis_text += f"- **Company**: {stock_data.get('company_name', 'N/A')}\n"
+            analysis_text += f"- **Sector**: {stock_data.get('sector', 'N/A')}\n"
+            analysis_text += f"- **Industry**: {stock_data.get('industry', 'N/A')}\n"
+            analysis_text += f"- **Market Cap**: {stock_data.get('market_cap', 'N/A')}\n\n"
+            
+            # Financial Metrics
+            financials = stock_data.get("financials", {})
+            if financials:
+                analysis_text += "## 💹 **Key Financial Metrics**\n"
+                
+                # Valuation metrics
+                pe_ratio = financials.get("pe_ratio", "N/A")
+                pb_ratio = financials.get("pb_ratio", "N/A")
+                ps_ratio = financials.get("ps_ratio", "N/A")
+                
+                analysis_text += f"- **P/E Ratio**: {pe_ratio}"
+                if pe_ratio != "N/A" and isinstance(pe_ratio, (int, float)):
+                    if pe_ratio < 15:
+                        analysis_text += " 🟢 (Undervalued)"
+                    elif pe_ratio > 25:
+                        analysis_text += " 🔴 (Potentially Overvalued)"
+                    else:
+                        analysis_text += " 🟡 (Fairly Valued)"
+                analysis_text += "\n"
+                
+                analysis_text += f"- **P/B Ratio**: {pb_ratio}\n"
+                analysis_text += f"- **P/S Ratio**: {ps_ratio}\n"
+                
+                # Profitability metrics
+                analysis_text += f"- **ROE**: {financials.get('roe', 'N/A')}\n"
+                analysis_text += f"- **ROA**: {financials.get('roa', 'N/A')}\n"
+                analysis_text += f"- **Profit Margin**: {financials.get('profit_margin', 'N/A')}\n"
+                analysis_text += f"- **Revenue Growth**: {financials.get('revenue_growth', 'N/A')}\n\n"
+            
+            # Performance analysis with trend indicators
+            performance = stock_data.get("performance", {})
+            if performance:
+                analysis_text += "## 📊 **Performance Analysis**\n"
+                
+                periods = ["1d", "1w", "1m", "3m", "6m", "1y", "ytd"]
+                for period in periods:
+                    if period in performance:
+                        return_pct = performance[period]
+                        
+                        # Add trend indicators
+                        if isinstance(return_pct, str) and "%" in return_pct:
+                            try:
+                                pct_value = float(return_pct.replace("%", ""))
+                                if pct_value > 0:
+                                    trend = "📈"
+                                elif pct_value < 0:
+                                    trend = "📉"
+                                else:
+                                    trend = "➡️"
+                            except:
+                                trend = ""
+                        else:
+                            trend = ""
+                        
+                        analysis_text += f"- **{period.upper()}**: {return_pct} {trend}\n"
+                analysis_text += "\n"
+            
+            # Advanced Risk Assessment
+            risk_data = stock_data.get("risk_assessment", {})
+            if risk_data:
+                analysis_text += "## ⚠️ **Risk Assessment**\n"
+                
+                risk_level = risk_data.get('risk_level', 'N/A')
+                volatility = risk_data.get('volatility_30d', 'N/A')
+                beta = risk_data.get('beta', 'N/A')
+                
+                # Risk level with emoji indicators
+                if risk_level.lower() == "low":
+                    risk_emoji = "🟢"
+                elif risk_level.lower() == "medium":
+                    risk_emoji = "🟡"
+                elif risk_level.lower() == "high":
+                    risk_emoji = "🔴"
+                else:
+                    risk_emoji = ""
+                
+                analysis_text += f"- **Risk Level**: {risk_level} {risk_emoji}\n"
+                analysis_text += f"- **30-Day Volatility**: {volatility}\n"
+                analysis_text += f"- **Beta**: {beta}"
+                
+                if beta != "N/A" and isinstance(beta, (int, float)):
+                    if beta > 1.2:
+                        analysis_text += " (High volatility vs market)"
+                    elif beta < 0.8:
+                        analysis_text += " (Low volatility vs market)"
+                    else:
+                        analysis_text += " (Similar to market)"
+                analysis_text += "\n\n"
+            
+            # Technical Analysis
+            technical = stock_data.get("technical_analysis", {})
+            if technical:
+                analysis_text += "## 📈 **Technical Analysis**\n"
+                analysis_text += f"- **50-Day MA**: {technical.get('ma_50', 'N/A')}\n"
+                analysis_text += f"- **200-Day MA**: {technical.get('ma_200', 'N/A')}\n"
+                analysis_text += f"- **RSI**: {technical.get('rsi', 'N/A')}\n"
+                analysis_text += f"- **Support Level**: {technical.get('support', 'N/A')}\n"
+                analysis_text += f"- **Resistance Level**: {technical.get('resistance', 'N/A')}\n\n"
+            
+            # Investment Recommendation with detailed reasoning
+            recommendation = stock_data.get("recommendation", {})
+            if recommendation:
+                action = recommendation.get('action', 'N/A')
+                confidence = recommendation.get('confidence', 'N/A')
+                reasoning = recommendation.get('reasoning', '')
+                
+                analysis_text += "## 💡 **Investment Recommendation**\n"
+                
+                # Action with emoji
+                if action.lower() == "buy":
+                    action_emoji = "🟢"
+                elif action.lower() == "sell":
+                    action_emoji = "🔴"
+                elif action.lower() == "hold":
+                    action_emoji = "🟡"
+                else:
+                    action_emoji = ""
+                
+                analysis_text += f"- **Action**: {action} {action_emoji}\n"
+                analysis_text += f"- **Confidence**: {confidence}\n"
+                
+                if reasoning:
+                    analysis_text += f"- **Reasoning**: {reasoning}\n"
+                
+                analysis_text += "\n"
+            
+            # Additional Investment Considerations
+            analysis_text += "## 🎯 **Investment Considerations**\n"
+            
+            # Dividend info
+            dividend_yield = stock_data.get("dividend_yield", "N/A")
+            if dividend_yield != "N/A":
+                analysis_text += f"- **Dividend Yield**: {dividend_yield}\n"
+            
+            # Analyst ratings
+            analyst_rating = stock_data.get("analyst_rating", "N/A")
+            if analyst_rating != "N/A":
+                analysis_text += f"- **Analyst Rating**: {analyst_rating}\n"
+            
+            # Price targets
+            price_target = stock_data.get("price_target", "N/A")
+            if price_target != "N/A":
+                analysis_text += f"- **Price Target**: {price_target}\n"
+            
+            # ESG score
+            esg_score = stock_data.get("esg_score", "N/A")
+            if esg_score != "N/A":
+                analysis_text += f"- **ESG Score**: {esg_score}\n"
+            
+            return analysis_text
+        except Exception as e:
+            return f"Error analyzing stock data: {str(e)}"
+
+    return None
+
+
+def determine_intended_tool(message):
+    """Determine which tool the AI intends to use based on the message"""
+    message_lower = message.lower()
+    
+    tool_detection_map = {
+        "budget_planner": ["budget", "income", "expense", "spending", "allocat", "monthly", "plan", "financial plan", "money"],
+        "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"]
+    }
+    
+    tool_names = {
+        "budget_planner": "Budget Planner",
+        "investment_analyzer": "Investment Analyzer", 
+        "expense_tracker": "Expense Tracker",
+        "market_trends": "Market Trends Analyzer",
+        "portfolio_analyzer": "Portfolio Analyzer",
+    }
+    
+    for tool_key, keywords in tool_detection_map.items():
+        if any(keyword in message_lower for keyword in keywords):
+            return tool_key, tool_names.get(tool_key, tool_key)
+    
+    return None, None
+
+
+def determine_response_type(message):
+    """Determine if user wants detailed report or short response"""
+    message_lower = message.lower()
+    
+    # Keywords indicating detailed response preference
+    detailed_keywords = [
+        "detailed", "detail", "comprehensive", "thorough", "in-depth", "full analysis", 
+        "complete", "report", "breakdown", "explain", "elaborate", "deep dive",
+        "extensive", "detailed analysis", "full report", "comprehensive report"
+    ]
+    
+    # Keywords indicating short response preference  
+    short_keywords = [
+        "quick", "brief", "short", "summary", "concise", "simple", "fast",
+        "just tell me", "quickly", "in short", "tldr", "bottom line"
+    ]
+    
+    # Check for detailed indicators first
+    if any(keyword in message_lower for keyword in detailed_keywords):
+        return "detailed"
+    
+    # Check for short indicators
+    if any(keyword in message_lower for keyword in short_keywords):
+        return "short"
+    
+    # Default to short response
+    return "short"
+
+
+def process_financial_query(message, history):
+    """Process user queries through the financial agent with streaming response"""
+    # Get the actual user message from the last entry in history
+    if not history or len(history) == 0:
+        return history
+
+    # Extract the last user message
+    last_user_message = None
+    for msg in reversed(history):
+        if msg["role"] == "user":
+            last_user_message = msg["content"]
+            break
+
+    if not last_user_message:
+        return history
+
+    # Convert Gradio history to agent format (excluding the last user message we just added)
+    agent_history = []
+    for i, msg in enumerate(history[:-1]):  # Exclude the last message
+        agent_history.append(
+            {
+                "role": msg["role"],
+                "content": msg["content"]
+                if isinstance(msg["content"], str)
+                else str(msg["content"]),
+            }
+        )
+
+    # Start timer
+    start_time = time.time()
+    init_message_start_index = len(history)
+    
+    try:
+        # Show what tool will be used and processing status
+        intended_tool_key, intended_tool_name = determine_intended_tool(last_user_message)
+        response_type = determine_response_type(last_user_message)
+        
+        # Always show status for all tools with expected time estimates
+        if intended_tool_name:
+            if intended_tool_key == "market_trends":
+                status_msg = f"🔍 Fetching market news & analyzing trends (estimated 20-30 seconds)..."
+            elif intended_tool_key == "investment_analyzer":
+                status_msg = f"📈 Analyzing stock data & calculating metrics (estimated 10-15 seconds)..."
+            elif intended_tool_key == "budget_planner":
+                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)..."
+            
+            history.append(ChatMessage(role="assistant", content=status_msg))
+            yield history
+        else:
+            # If no tool detected, show generic processing message
+            history.append(ChatMessage(role="assistant", content=f"🧠 Processing your request (estimated 10-15 seconds)..."))
+            yield history
+        
+        # Process message through agent
+        response, tool_used, tool_result, all_tools, all_results = agent.process_message_with_details(
+            last_user_message, agent_history
+        )
+        
+        # Clear the processing message now that tool is complete
+        if len(history) > init_message_start_index:
+            history.pop()  # Remove the processing message
+        # Step 5: Show tool execution results
+        if all_tools and all_results:
+            # Remove initialization messages but keep all previous conversation and tool info
+            history = history[:init_message_start_index]
+            
+            tool_names = {
+                "budget_planner": "Budget Planner",
+                "investment_analyzer": "Investment Analyzer", 
+                "expense_tracker": "Expense Tracker",
+                "market_trends": "Market Trends Analyzer",
+                "portfolio_analyzer": "Portfolio Analyzer",
+            }
+            
+            tool_emojis = {
+                "Budget Planner": "💰",
+                "Investment Analyzer": "📈", 
+                "Expense Tracker": "💳",
+                "Market Trends Analyzer": "📰",
+                "Portfolio Analyzer": "📊",
+            }
+            
+            # Show results for all tools used
+            for i, (used_tool, result) in enumerate(zip(all_tools, all_results)):
+                tool_display_name = tool_names.get(used_tool, used_tool)
+                
+                if result:
+                    # Format tool result for display
+                    try:
+                        import json
+
+                        if result.startswith("{") or result.startswith("["):
+                            # Pretty format JSON output
+                            parsed_result = json.loads(result)
+                            # Truncate very long results for display
+                            if len(str(parsed_result)) > 2000:
+                                # Show summary for long results
+                                if isinstance(parsed_result, dict):
+                                    summary = {
+                                        k: f"[{type(v).__name__}]"
+                                        if isinstance(v, (list, dict))
+                                        else v
+                                        for k, v in list(parsed_result.items())[:10]
+                                    }
+                                    display_result = f"```json\n{json.dumps(summary, indent=2)}\n... (truncated)\n```"
+                                else:
+                                    display_result = f"```json\n{json.dumps(parsed_result, indent=2)[:1000]}...\n```"
+                            else:
+                                formatted_result = json.dumps(parsed_result, indent=2)
+                                display_result = f"```json\n{formatted_result}\n```"
+                        else:
+                            # Truncate non-JSON results
+                            display_result = (
+                                result[:1000] + "..."
+                                if len(result) > 1000
+                                else result
+                            )
+                    except Exception as e:
+                        display_result = (
+                            str(result)[:1000] + "..."
+                            if len(str(result)) > 1000
+                            else str(result)
+                        )
+
+                    tool_emoji = tool_emojis.get(tool_display_name, "🔧")
+                    
+                    collapsible_content = f"""
+<details>
+<summary><strong>{tool_emoji} {tool_display_name} Results</strong> - Click to expand</summary>
+
+{display_result}
+
+</details>
+"""
+                    
+                    history.append(ChatMessage(
+                        role="assistant",
+                        content=collapsible_content,
+                    ))
+                    yield history
+
+        # Add visualization for all applicable tools
+        if all_tools and all_results:
+            for used_tool, result in zip(all_tools, all_results):
+                if result and used_tool in ["budget_planner", "portfolio_analyzer", "investment_analyzer"]:
+                    viz_type = {
+                        "budget_planner": "budget",
+                        "portfolio_analyzer": "portfolio", 
+                        "investment_analyzer": "stock",
+                    }.get(used_tool)
+
+                    try:
+                        analysis_data = analyze_data_with_repl(viz_type, result)
+
+                        if analysis_data:
+                            tool_display_name = {
+                                "budget_planner": "Budget",
+                                "portfolio_analyzer": "Portfolio",
+                                "investment_analyzer": "Stock",
+                            }.get(used_tool, "Data")
+                            
+                            # Create collapsible data analysis output
+                            collapsible_analysis = f"""
+<details>
+<summary><strong>🔍 {tool_display_name} Data Analysis</strong> - Click to expand</summary>
+
+{analysis_data}
+
+</details>
+"""
+                            
+                            history.append(ChatMessage(
+                                role="assistant",
+                                content=collapsible_analysis,
+                            ))
+                            yield history
+
+                    except Exception as e:
+                        # Silently continue if analysis fails
+                        pass
+
+        # Stream the final response in real-time using LLM streaming
+        if tool_used and tool_result:
+            # Use real LLM streaming with response type
+            streaming_content = ""
+            history.append(ChatMessage(role="assistant", content=""))
+            
+            for chunk in agent.stream_response(last_user_message, tool_result, tool_used, response_type):
+                streaming_content += chunk
+                history[-1] = ChatMessage(role="assistant", content=streaming_content)
+                yield history
+        else:
+            # Fallback for non-streaming response
+            history.append(ChatMessage(role="assistant", content=response))
+            yield history
+
+        elapsed = time.time() - start_time
+
+    except Exception as e:
+        elapsed = time.time() - start_time
+        history[-1] = ChatMessage(
+            role="assistant",
+            content=f"I encountered an error while processing your request: {str(e)}. Please try rephrasing your question.",
+            metadata={"title": f"💥 Error ({elapsed:.1f}s)"},
+        )
+        yield history
+
+
+# Create the Gradio interface
+with gr.Blocks(theme=gr.themes.Base(), title="Financial Advisory Agent") as demo:
+    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>
+    """)
+
+    chatbot = gr.Chatbot(
+        type="messages",
+        scale=2,
+        height=400,
+        avatar_images=AVATAR_IMAGES,
+        show_copy_button=True,
+    )
+
+    with gr.Row(equal_height=True):
+        msg = gr.Textbox(
+            placeholder="Ask me about budgeting, investments, or any financial topic...",
+            show_label=False,
+            scale=19,
+            autofocus=True,
+        )
+        submit = gr.Button("Send", variant="primary", scale=1, min_width=60)
+
+    # Example queries
+    example_queries = [
+        "Analyze AAPL stock and tell me if it's a good investment",
+        "Help me create a budget with $5000 monthly income and expenses: rent $1500, food $500, utilities $200",
+        "What are the latest market trends in tech stocks?",
+        "Analyze my portfolio: {'holdings': [{'symbol': 'AAPL', 'shares': 100}, {'symbol': 'GOOGL', 'shares': 50}]}",
+    ]
+
+    gr.Examples(examples=example_queries, inputs=msg, label="Example Queries")
+
+    # Handle message submission
+    def user_submit(message, history):
+        if not message.strip():
+            return "", history, gr.update(interactive=True), gr.update(interactive=True)
+        history = history + [ChatMessage(role="user", content=message)]
+        return "", history, gr.update(interactive=False), gr.update(interactive=False)
+
+    def enable_input():
+        return gr.update(interactive=True), gr.update(interactive=True)
+
+    # Connect events
+    submit_event = (
+        msg.submit(user_submit, [msg, chatbot], [msg, chatbot, msg, submit])
+        .then(process_financial_query, [msg, chatbot], chatbot)
+        .then(enable_input, [], [msg, submit])
+    )
+
+    click_event = (
+        submit.click(user_submit, [msg, chatbot], [msg, chatbot, msg, submit])
+        .then(process_financial_query, [msg, chatbot], chatbot)
+        .then(enable_input, [], [msg, submit])
+    )
+
+    # Add like functionality for feedback
+    def like_handler(evt: gr.LikeData):
+        pass
+
+    chatbot.like(like_handler)
+
+if __name__ == "__main__":
+    demo.launch(debug=True)

requirements.txt

@@ -0,0 +1,10 @@
+gradio==5.33.0
+langgraph==0.4.8
+langchain==0.3.25
+langchain-openai==0.3.21
+langchain-community==0.3.24
+tavily-python==0.7.5
+yfinance==0.2.62
+pandas==2.3.0
+numpy==2.3.0
+requests==2.32.3