Upload 6 files

agents/financial_agent.py

@@ -0,0 +1,397 @@
+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
+from langchain_cohere import ChatCohere
+
+
+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):
+    #def __init__(self, tools: List[Tool], cohere_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.llm = ChatCohere(
+            #cohere_api_key=cohere_api_key, model="command-a-03-2025", temperature=0.1
+        #)
+        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).
+- 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":
+            # Use OpenAI to extract stock symbol from natural language
+            extraction_prompt = f"""Extract the stock symbol from this message: "{message}"
+
+If the user mentions a company name, return the corresponding stock ticker symbol.
+If they mention a ticker symbol directly, return that symbol.
+If no stock or company is mentioned, return "UNKNOWN".
+
+Examples:
+- "Tell me about NVIDIA" -> "NVDA"
+- "Analyze AAPL stock" -> "AAPL" 
+- "How is Tesla doing?" -> "TSLA"
+- "What about Microsoft stock?" -> "MSFT"
+
+Return only the stock symbol, nothing else."""
+
+            try:
+                response = self.llm.invoke([
+                    SystemMessage(content="You are a stock symbol extraction assistant. Return only the ticker symbol."),
+                    HumanMessage(content=extraction_prompt)
+                ])
+                
+                extracted_symbol = response.content.strip().upper()
+                if extracted_symbol and extracted_symbol != "UNKNOWN":
+                    return extracted_symbol
+                
+            except Exception:
+                pass
+            
+            # Fallback to regex if LLM fails
+            symbols = re.findall(r"\b[A-Z]{2,5}\b", message)
+            return symbols[0] if symbols else ""
+
+        elif tool_name == "budget_planner":
+            # Use OpenAI to extract budget information from natural language
+            extraction_prompt = f"""Extract budget information from this message: "{message}"
+
+Extract:
+1. Monthly income (if mentioned)
+2. Expenses by category (rent, food, utilities, transportation, etc.)
+
+Return as JSON format:
+{{"income": 5000, "expenses": {{"rent": 1500, "food": 500, "utilities": 200}}}}
+
+If income is not mentioned, use 5000 as default.
+If no expenses are mentioned, return empty expenses object.
+
+Examples:
+- "I make $6000 monthly, rent is $1800, food $600" -> {{"income": 6000, "expenses": {{"rent": 1800, "food": 600}}}}
+- "Help with budget, income 4500, utilities 150" -> {{"income": 4500, "expenses": {{"utilities": 150}}}}
+
+Return only valid JSON, nothing else. answer in japanese."""
+
+            try:
+                response = self.llm.invoke([
+                    SystemMessage(content="You are a budget data extraction assistant. Return only valid JSON."),
+                    HumanMessage(content=extraction_prompt)
+                ])
+                
+                # Try to parse the JSON response
+                extracted_data = response.content.strip()
+                # Remove any markdown formatting
+                if extracted_data.startswith("```"):
+                    extracted_data = extracted_data.split("\n")[1:-1]
+                    extracted_data = "\n".join(extracted_data)
+                
+                # Validate JSON
+                json.loads(extracted_data)
+                return extracted_data
+                
+            except Exception:
+                pass
+            
+            # Fallback to regex extraction
+            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
+            
+            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":
+            # Use OpenAI to extract portfolio information from natural language
+            extraction_prompt = f"""Extract portfolio holdings and total investment from this message: "{message}"
+
+Convert the portfolio information to JSON format with holdings array and total investment amount.
+Each holding should have symbol and either shares or percentage.
+
+Return format:
+{{"holdings": [{{"symbol": "AAPL", "shares": 100}}, {{"symbol": "GOOGL", "percentage": 30}}], "total_investment": 100000}}
+
+Examples:
+- "My portfolio: AAPL 100 shares, GOOGL 50 shares" -> {{"holdings": [{{"symbol": "AAPL", "shares": 100}}, {{"symbol": "GOOGL", "shares": 50}}], "total_investment": 0}}
+- "I have 40% AAPL, 30% MSFT, 30% TSLA. I have invested total of 100K USD" -> {{"holdings": [{{"symbol": "AAPL", "percentage": 40}}, {{"symbol": "MSFT", "percentage": 30}}, {{"symbol": "TSLA", "percentage": 30}}], "total_investment": 100000}}
+- "Portfolio with Apple 200 shares and Microsoft 25%, total investment $50,000" -> {{"holdings": [{{"symbol": "AAPL", "shares": 200}}, {{"symbol": "MSFT", "percentage": 25}}], "total_investment": 50000}}
+
+Important:
+- Extract total investment amount if mentioned (convert K=1000, M=1000000)
+- If total investment not mentioned, set to 0
+- Convert company names to stock symbols (Apple->AAPL, Microsoft->MSFT, Tesla->TSLA, etc.)
+
+If no clear portfolio data is found, return: {{"holdings": [], "total_investment": 0}}
+
+Return only valid JSON in japanese Yen, nothing else."""
+
+            try:
+                response = self.llm.invoke([
+                    SystemMessage(content="You are a portfolio data extraction assistant. Return only valid JSON with holdings array and total_investment field."),
+                    HumanMessage(content=extraction_prompt)
+                ])
+                
+                # Try to parse the JSON response
+                extracted_data = response.content.strip()
+                # Remove any markdown formatting
+                if extracted_data.startswith("```"):
+                    lines = extracted_data.split("\n")
+                    # Find the start and end of JSON content
+                    start_idx = 1 if lines[0].startswith("```") else 0
+                    end_idx = -1 if lines[-1].startswith("```") or lines[-1] == "```" else len(lines)
+                    extracted_data = "\n".join(lines[start_idx:end_idx])
+                
+                # Validate JSON
+                parsed_json = json.loads(extracted_data)
+                # Ensure it has the required structure
+                if isinstance(parsed_json, dict) and "holdings" in parsed_json:
+                    return extracted_data
+                else:
+                    # If structure is wrong, fall back to regex
+                    pass
+                
+            except Exception:
+                pass
+            
+            # Fallback to returning the original message
+            return message
+
+        elif tool_name == "market_trends":
+            # Use OpenAI to extract and refine market research query
+            extraction_prompt = f"""Convert this user message into an optimized market research query: "{message}"
+
+Create a focused search query that will get the best market trends and financial news results.
+
+Examples:
+- "What's happening in tech stocks?" -> "technology stocks market trends latest news 2025"
+- "Tell me about the market today" -> "stock market trends today financial news latest"
+- "How is the crypto market?" -> "cryptocurrency market trends bitcoin ethereum latest news"
+- "What about NVIDIA trends?" -> "NVIDIA NVDA stock market trends analysis latest news"
+
+Return only the optimized search query, nothing else."""
+
+            try:
+                response = self.llm.invoke([
+                    SystemMessage(content="You are a search query optimization assistant. Return only the optimized search query."),
+                    HumanMessage(content=extraction_prompt)
+                ])
+                
+                optimized_query = response.content.strip()
+                return optimized_query if optimized_query else message
+                
+            except Exception:
+                pass
+            
+            # Fallback to returning the original message
+            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", "track", "categoriz"],
+            "investment_analyzer": ["stock", "invest", "buy", "sell", "analyze"],
+            "portfolio_analyzer": ["portfolio", "holdings", "allocation", "diversif"],
+            "market_trends": ["market", "trend", "news", "sector", "economic"]
+        }
+        
+        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} Always answer in japanese.
+
+Data: {tool_result}
+
+Keep response under 200 words with key insights and 2-3 actionable recommendations. Always answer in japanese."""
+
+                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
+- Always answer in japanese"""
+
+            system_message = "You are a professional financial advisor. Provide comprehensive, detailed advice based on the analysis results. Be thorough and educational. Always answer in japanese."
+        else:
+            response_prompt = f"""Based on this {selected_tool.replace('_', ' ')} analysis, provide a concise financial summary for: {message}. Always answer in japanese.
+
+Data: {tool_result}
+
+Keep response under 200 words with key insights and 2-3 actionable recommendations. Always answer in japanese."""
+
+            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,756 @@
+import json
+from datetime import datetime
+from typing import List
+
+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:
+                # Handle empty or invalid input
+                if not input_str or input_str.strip() == "":
+                    input_str = '{"income": 5000, "expenses": {}}'
+
+                # Try to parse JSON, if it fails, try to extract values from text
+                try:
+                    data = json.loads(input_str)
+                except json.JSONDecodeError:
+                    # Fallback: extract income and expenses from text
+                    import re
+
+                    income_match = re.search(r"(\$?[\d,]+(?:\.\d{2})?)", input_str)
+                    income = (
+                        float(income_match.group(1).replace("$", "").replace(",", ""))
+                        if income_match
+                        else 5000
+                    )
+                    data = {"income": income, "expenses": {}}
+
+                income = data.get("income", 5000)
+                expenses = data.get("expenses", {})
+                goals = data.get("savings_goals", {})
+                debt = data.get("debt", {})
+
+                # 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_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(
+                        "✅ 市場指数データが​​正常に取得されました。"
+                    )
+
+                    # Simple sentiment based on available indices
+                    if index_data:
+                        status_updates.append("🧠 市場センチメントの分析...")
+                        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} 指数は正",
+                        }
+                        status_updates.append("✅ 市場センチメント分析が完了しました。")
+
+                except Exception as index_error:
+                    status_updates.append(
+                        f"❌ 市場指数の取得中にエラーが発生しました。: {str(index_error)}"
+                    )
+                    index_data = {
+                        "error": f"インデックスデータが利用不可: {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:
+                import re
+
+                # Try to parse as JSON first (from OpenAI extraction)
+                total_investment = 0
+                holdings_info = []
+                
+                try:
+                    # First try to parse as JSON
+                    data = json.loads(input_str)
+                    if isinstance(data, dict):
+                        holdings_info = data.get("holdings", [])
+                        total_investment = data.get("total_investment", 0)
+                except:
+                    # If JSON parsing fails, extract from natural language
+                    pass
+
+                # If no JSON data found, extract from natural language using regex
+                if not holdings_info:
+                    # Extract investment amount using improved patterns
+                    def extract_investment_amount(text):
+                        patterns = [
+                            r"(?:invested|investment|total|have)\s*(?:of)?\s*(?:\$)?(\d+(?:[,\d]*)?(?:\.\d+)?)\s*([KMB]?)\s*(?:USD|dollars?|\$)?",
+                            r"(\d+(?:[,\d]*)?(?:\.\d+)?)\s*([KMB]?)\s*(?:USD|dollars?)",
+                            r"\$(\d+(?:[,\d]*)?(?:\.\d+)?)\s*([KMB]?)",
+                        ]
+                        
+                        for pattern in patterns:
+                            match = re.search(pattern, text, re.IGNORECASE)
+                            if match:
+                                amount_str = match.group(1).replace(",", "")
+                                suffix = match.group(2).upper() if len(match.groups()) > 1 else ""
+                                
+                                multiplier = {"K": 1000, "M": 1000000, "B": 1000000000}.get(suffix, 1)
+                                return float(amount_str) * multiplier
+                        return 0
+
+                    if total_investment == 0:
+                        total_investment = extract_investment_amount(input_str)
+
+                    # Extract holdings using regex
+                    def extract_holdings(text):
+                        holdings = []
+                        
+                        # First try percentage patterns (with % symbol)
+                        percentage_patterns = [
+                            r"([A-Z]{2,5})\s*[:\s]*(\d+(?:\.\d+)?)%",
+                            r"([A-Z]{2,5}):\s*(\d+(?:\.\d+)?)%",
+                            r"([A-Z]{2,5})\s+(\d+(?:\.\d+)?)%",
+                        ]
+                        
+                        for pattern in percentage_patterns:
+                            matches = re.findall(pattern, text, re.IGNORECASE)
+                            if matches:
+                                for symbol, percentage in matches:
+                                    holdings.append({
+                                        "symbol": symbol.upper(),
+                                        "percentage": float(percentage)
+                                    })
+                                return holdings
+                        
+                        # If no percentages found, try shares patterns (without % symbol)
+                        shares_patterns = [
+                            r"([A-Z]{2,5})\s*[:\s]*(\d+(?:\.\d+)?)\s*(?!%)",
+                            r"([A-Z]{2,5}):\s*(\d+(?:\.\d+)?)\s*(?!%)",
+                            r"([A-Z]{2,5})\s+(\d+(?:\.\d+)?)\s*(?!%)",
+                        ]
+                        
+                        for pattern in shares_patterns:
+                            matches = re.findall(pattern, text, re.IGNORECASE)
+                            if matches:
+                                for symbol, shares in matches:
+                                    holdings.append({
+                                        "symbol": symbol.upper(),
+                                        "shares": float(shares)
+                                    })
+                                return holdings
+                        
+                        return holdings
+
+                    holdings_info = extract_holdings(input_str)
+                
+                # If no valid holdings found, return early to avoid using this tool
+                if not holdings_info:
+                    # Debug: show what we received
+                    return f"Portfolio analyzer debug - received input: {input_str[:200]}... No holdings found. Please provide portfolio details like 'AAPL 40%, MSFT 30%' or JSON format."
+
+                portfolio_data = []
+                total_calculated_value = 0
+
+                # Process each holding
+                for holding in holdings_info:
+                    symbol = holding.get("symbol", "")
+                    percentage = holding.get("percentage", 0)
+                    shares = holding.get("shares", None)
+
+                    if not symbol:
+                        continue
+
+                    try:
+                        # Get current stock price
+                        stock = yf.Ticker(symbol)
+                        hist = stock.history(period="1d")
+
+                        if not hist.empty:
+                            current_price = hist["Close"].iloc[-1]
+
+                            if shares is not None:
+                                # Shares-based calculation
+                                value = current_price * shares
+                                allocation_percentage = percentage
+                            else:
+                                # Percentage-based calculation
+                                value = total_investment * (percentage / 100)
+                                allocation_percentage = percentage
+                                shares = value / current_price if current_price > 0 else 0
+
+                            total_calculated_value += value
+
+                            portfolio_data.append(
+                                {
+                                    "symbol": symbol,
+                                    "shares": round(shares, 2),
+                                    "current_price": f"${current_price:.2f}",
+                                    "value": value,
+                                    "allocation": allocation_percentage,
+                                }
+                            )
+                    except Exception:
+                        # Skip if can't get data but add placeholder
+                        if percentage > 0:
+                            value = total_investment * (percentage / 100)
+                            portfolio_data.append(
+                                {
+                                    "symbol": symbol,
+                                    "shares": "N/A",
+                                    "current_price": "N/A",
+                                    "value": value,
+                                    "allocation": percentage,
+                                }
+                            )
+
+                # For percentage-based portfolios, use the original total investment
+                # For share-based portfolios, use calculated value
+                final_total_value = (
+                    total_investment 
+                    if total_investment > 0 and any(h.get("percentage", 0) > 0 for h in holdings_info)
+                    else total_calculated_value
+                )
+
+                # Analysis and recommendations
+                analysis = {
+                    "total_portfolio_value": f"${final_total_value:.2f}",
+                    "number_of_holdings": len(portfolio_data),
+                    "holdings": portfolio_data,
+                    "recommendations": [],
+                }
+
+                # Diversification recommendations
+                if len(portfolio_data) < 5:
+                    analysis["recommendations"].append(
+                        "Consider diversifying with more holdings"
+                    )
+
+                if portfolio_data:
+                    max_allocation = max(item["allocation"] for item in portfolio_data)
+                    if max_allocation > 40:
+                        analysis["recommendations"].append(
+                            f"High concentration risk: largest holding is {max_allocation:.1f}%"
+                        )
+                    elif max_allocation > 30:
+                        analysis["recommendations"].append(
+                            f"Moderate concentration risk: largest holding is {max_allocation:.1f}%"
+                        )
+
+                # Check if allocations add up to 100%
+                total_allocation = sum(item["allocation"] for item in portfolio_data)
+                if abs(total_allocation - 100) > 5:
+                    analysis["recommendations"].append(
+                        f"Portfolio allocations total {total_allocation:.1f}% - consider rebalancing to 100%"
+                    )
+
+                # Sector diversification recommendation
+                if len(portfolio_data) == 3:
+                    analysis["recommendations"].append(
+                        "Consider adding holdings from different sectors (healthcare, utilities, financials)"
+                    )
+
+                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. Input should include holdings like: [{'symbol': 'AAPL', 'shares': 100}]",
+            func=portfolio_analyzer,
+        )
+
+    def get_all_tools(self) -> List[Tool]:
+        return [
+            self.create_budget_planner(),
+            self.create_investment_analyzer(),
+            self.create_market_trends_analyzer(),
+            self.create_portfolio_analyzer(),
+        ]