Update market_intelligence_dashboard.py - Voice Streaming & AI Coaching Features

market_intelligence_dashboard.py

@@ -0,0 +1,966 @@
+"""
+Real-time Market Intelligence Dashboard for NAVADA
+Provides comprehensive market data, trends, and competitive intelligence
+"""
+
+import asyncio
+import json
+import logging
+import os
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timedelta
+import yfinance as yf
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import requests
+from openai import AsyncOpenAI
+
+logger = logging.getLogger(__name__)
+
+class MarketIntelligenceEngine:
+    """Core engine for gathering and analyzing market intelligence data"""
+
+    def __init__(self):
+        self.client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        self.search_api_key = os.getenv("SEARCH_API_KEY")
+        self.data_cache = {}
+        self.cache_expiry = {}
+
+    async def get_market_overview(self, sector: str = "technology") -> Dict[str, Any]:
+        """Get comprehensive market overview for a specific sector"""
+        try:
+            cache_key = f"market_overview_{sector}"
+            if self._is_cache_valid(cache_key):
+                return self.data_cache[cache_key]
+
+            # Get major sector ETFs and indices
+            sector_symbols = self._get_sector_symbols(sector)
+
+            market_data = {}
+            for symbol, name in sector_symbols.items():
+                try:
+                    ticker = yf.Ticker(symbol)
+                    hist = ticker.history(period="1y")
+                    info = ticker.info
+
+                    if not hist.empty:
+                        current_price = hist['Close'].iloc[-1]
+                        ytd_change = ((current_price - hist['Close'].iloc[0]) / hist['Close'].iloc[0]) * 100
+
+                        market_data[symbol] = {
+                            "name": name,
+                            "current_price": float(current_price),
+                            "ytd_change": float(ytd_change),
+                            "volume": float(hist['Volume'].iloc[-1]),
+                            "market_cap": info.get('totalAssets', 0),
+                            "52_week_high": float(hist['High'].max()),
+                            "52_week_low": float(hist['Low'].min())
+                        }
+                except Exception as e:
+                    logger.warning(f"Error fetching data for {symbol}: {e}")
+                    continue
+
+            # Generate market insights using AI
+            market_insights = await self._generate_market_insights(market_data, sector)
+
+            result = {
+                "sector": sector,
+                "timestamp": datetime.now().isoformat(),
+                "market_data": market_data,
+                "insights": market_insights,
+                "total_symbols": len(market_data)
+            }
+
+            self._cache_data(cache_key, result, hours=1)
+            return result
+
+        except Exception as e:
+            logger.error(f"Error getting market overview: {e}")
+            return {"status": "error", "message": str(e)}
+
+    def _get_sector_symbols(self, sector: str) -> Dict[str, str]:
+        """Get relevant ETF and index symbols for a sector"""
+        sector_mappings = {
+            "technology": {
+                "QQQ": "NASDAQ-100 Technology",
+                "XLK": "Technology Select Sector SPDR",
+                "VGT": "Vanguard Information Technology ETF",
+                "SOXX": "iShares Semiconductor ETF",
+                "ARKK": "ARK Innovation ETF"
+            },
+            "healthcare": {
+                "XLV": "Health Care Select Sector SPDR",
+                "VHT": "Vanguard Health Care ETF",
+                "IBB": "iShares Biotechnology ETF",
+                "XBI": "SPDR Biotech ETF"
+            },
+            "finance": {
+                "XLF": "Financial Select Sector SPDR",
+                "VFH": "Vanguard Financials ETF",
+                "KBE": "SPDR Banking ETF",
+                "KRE": "SPDR Regional Banking ETF"
+            },
+            "energy": {
+                "XLE": "Energy Select Sector SPDR",
+                "VDE": "Vanguard Energy ETF",
+                "XOP": "SPDR Oil & Gas Exploration ETF",
+                "ICLN": "iShares Clean Energy ETF"
+            },
+            "retail": {
+                "XRT": "SPDR Retail ETF",
+                "RTH": "VanEck Retail ETF",
+                "ONLN": "ProShares Online Retail ETF",
+                "XLY": "Consumer Discretionary SPDR"
+            }
+        }
+
+        return sector_mappings.get(sector, sector_mappings["technology"])
+
+    async def _generate_market_insights(self, market_data: Dict, sector: str) -> str:
+        """Generate AI-powered insights from market data"""
+        try:
+            system_prompt = f"""
+            You are a senior market analyst providing insights on the {sector} sector.
+            Analyze the provided market data and generate 3-4 key insights covering:
+            1. Overall sector performance and trends
+            2. Notable winners and losers
+            3. Market sentiment and outlook
+            4. Potential opportunities or risks
+
+            Keep insights concise, data-driven, and actionable for startup founders.
+            """
+
+            user_prompt = f"""
+            Sector: {sector}
+            Market Data Summary:
+            {json.dumps(market_data, indent=2)}
+
+            Provide professional market analysis with specific insights for startup founders in this sector.
+            """
+
+            response = await self.client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=400,
+                temperature=0.3
+            )
+
+            return response.choices[0].message.content
+
+        except Exception as e:
+            logger.error(f"Error generating market insights: {e}")
+            return "Market insights temporarily unavailable."
+
+    async def get_competitive_landscape(self, company_name: str, industry: str) -> Dict[str, Any]:
+        """Analyze competitive landscape for a specific company/industry"""
+        try:
+            cache_key = f"competitive_{company_name}_{industry}"
+            if self._is_cache_valid(cache_key):
+                return self.data_cache[cache_key]
+
+            # Get industry leaders and competitors
+            competitors = await self._identify_competitors(company_name, industry)
+
+            competitive_data = {}
+            for competitor in competitors[:10]:  # Limit to top 10
+                try:
+                    ticker = yf.Ticker(competitor["symbol"])
+                    info = ticker.info
+                    hist = ticker.history(period="1y")
+
+                    if not hist.empty:
+                        competitive_data[competitor["symbol"]] = {
+                            "name": competitor["name"],
+                            "market_cap": info.get('marketCap', 0),
+                            "revenue": info.get('totalRevenue', 0),
+                            "employees": info.get('fullTimeEmployees', 0),
+                            "pe_ratio": info.get('trailingPE', 0),
+                            "profit_margin": info.get('profitMargins', 0),
+                            "revenue_growth": info.get('revenueGrowth', 0),
+                            "current_price": float(hist['Close'].iloc[-1]),
+                            "ytd_performance": ((hist['Close'].iloc[-1] - hist['Close'].iloc[0]) / hist['Close'].iloc[0]) * 100
+                        }
+                except Exception as e:
+                    logger.warning(f"Error fetching competitor data for {competitor}: {e}")
+                    continue
+
+            # Generate competitive analysis
+            analysis = await self._generate_competitive_analysis(competitive_data, company_name, industry)
+
+            result = {
+                "company": company_name,
+                "industry": industry,
+                "timestamp": datetime.now().isoformat(),
+                "competitors": competitive_data,
+                "analysis": analysis,
+                "market_leaders": self._identify_market_leaders(competitive_data)
+            }
+
+            self._cache_data(cache_key, result, hours=6)
+            return result
+
+        except Exception as e:
+            logger.error(f"Error getting competitive landscape: {e}")
+            return {"status": "error", "message": str(e)}
+
+    async def _identify_competitors(self, company_name: str, industry: str) -> List[Dict[str, str]]:
+        """Identify key competitors using AI and market data"""
+        try:
+            # Use AI to identify competitors
+            system_prompt = """
+            You are a market research analyst. Identify the top public competitors for the given company and industry.
+            Return a JSON list of competitors with their stock symbols and full company names.
+            Format: [{"symbol": "AAPL", "name": "Apple Inc."}, ...]
+            Focus on direct competitors that are publicly traded.
+            """
+
+            user_prompt = f"""
+            Company: {company_name}
+            Industry: {industry}
+
+            Identify 8-12 key public competitors with their stock symbols.
+            """
+
+            response = await self.client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=300,
+                temperature=0.3
+            )
+
+            try:
+                competitors = json.loads(response.choices[0].message.content)
+                return competitors if isinstance(competitors, list) else []
+            except json.JSONDecodeError:
+                logger.warning("Failed to parse competitors JSON")
+                return []
+
+        except Exception as e:
+            logger.error(f"Error identifying competitors: {e}")
+            return []
+
+    async def _generate_competitive_analysis(self, competitive_data: Dict, company_name: str, industry: str) -> str:
+        """Generate AI-powered competitive analysis"""
+        try:
+            system_prompt = f"""
+            You are a senior business analyst providing competitive intelligence for {company_name} in the {industry} industry.
+
+            Analyze the competitive landscape and provide insights on:
+            1. Market positioning and differentiation opportunities
+            2. Financial performance benchmarks
+            3. Strategic threats and opportunities
+            4. Market dynamics and trends
+
+            Be specific and actionable for startup strategy.
+            """
+
+            user_prompt = f"""
+            Company: {company_name}
+            Industry: {industry}
+
+            Competitive Data:
+            {json.dumps(competitive_data, indent=2)}
+
+            Provide strategic competitive analysis with actionable insights.
+            """
+
+            response = await self.client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=500,
+                temperature=0.3
+            )
+
+            return response.choices[0].message.content
+
+        except Exception as e:
+            logger.error(f"Error generating competitive analysis: {e}")
+            return "Competitive analysis temporarily unavailable."
+
+    def _identify_market_leaders(self, competitive_data: Dict) -> List[Dict[str, Any]]:
+        """Identify market leaders based on key metrics"""
+        try:
+            if not competitive_data:
+                return []
+
+            # Sort by market cap and revenue
+            sorted_by_market_cap = sorted(
+                competitive_data.items(),
+                key=lambda x: x[1].get('market_cap', 0),
+                reverse=True
+            )
+
+            leaders = []
+            for symbol, data in sorted_by_market_cap[:5]:
+                leaders.append({
+                    "symbol": symbol,
+                    "name": data.get('name', symbol),
+                    "market_cap": data.get('market_cap', 0),
+                    "revenue": data.get('revenue', 0),
+                    "market_position": "Leader" if len(leaders) == 0 else "Major Player"
+                })
+
+            return leaders
+
+        except Exception as e:
+            logger.error(f"Error identifying market leaders: {e}")
+            return []
+
+    async def get_trend_analysis(self, keywords: List[str], timeframe: str = "1y") -> Dict[str, Any]:
+        """Analyze market trends for specific keywords/topics"""
+        try:
+            cache_key = f"trends_{'_'.join(keywords)}_{timeframe}"
+            if self._is_cache_valid(cache_key):
+                return self.data_cache[cache_key]
+
+            # Analyze related stocks and ETFs
+            trend_data = {}
+            for keyword in keywords:
+                related_symbols = await self._find_related_symbols(keyword)
+
+                keyword_performance = {}
+                for symbol in related_symbols[:5]:  # Top 5 related symbols
+                    try:
+                        ticker = yf.Ticker(symbol)
+                        hist = ticker.history(period=timeframe)
+
+                        if not hist.empty:
+                            performance = ((hist['Close'].iloc[-1] - hist['Close'].iloc[0]) / hist['Close'].iloc[0]) * 100
+                            keyword_performance[symbol] = {
+                                "performance": float(performance),
+                                "volatility": float(hist['Close'].std()),
+                                "volume_avg": float(hist['Volume'].mean())
+                            }
+                    except Exception as e:
+                        logger.warning(f"Error analyzing {symbol}: {e}")
+                        continue
+
+                trend_data[keyword] = keyword_performance
+
+            # Generate trend insights
+            insights = await self._generate_trend_insights(trend_data, keywords, timeframe)
+
+            result = {
+                "keywords": keywords,
+                "timeframe": timeframe,
+                "timestamp": datetime.now().isoformat(),
+                "trend_data": trend_data,
+                "insights": insights
+            }
+
+            self._cache_data(cache_key, result, hours=2)
+            return result
+
+        except Exception as e:
+            logger.error(f"Error getting trend analysis: {e}")
+            return {"status": "error", "message": str(e)}
+
+    async def _find_related_symbols(self, keyword: str) -> List[str]:
+        """Find stock symbols related to a keyword"""
+        # This is a simplified implementation
+        # In production, you might use more sophisticated symbol mapping
+        keyword_mappings = {
+            "ai": ["NVDA", "GOOGL", "MSFT", "AMD", "INTC"],
+            "cloud": ["AMZN", "MSFT", "GOOGL", "CRM", "SNOW"],
+            "fintech": ["SQ", "PYPL", "V", "MA", "COIN"],
+            "biotech": ["GILD", "AMGN", "BIIB", "REGN", "VRTX"],
+            "ev": ["TSLA", "F", "GM", "NIO", "RIVN"],
+            "crypto": ["COIN", "MSTR", "RIOT", "MARA", "HOOD"]
+        }
+
+        return keyword_mappings.get(keyword.lower(), ["SPY"])
+
+    async def _generate_trend_insights(self, trend_data: Dict, keywords: List[str], timeframe: str) -> str:
+        """Generate AI insights about market trends"""
+        try:
+            system_prompt = f"""
+            You are a market trend analyst providing insights on emerging trends and market dynamics.
+
+            Analyze the trend data for the keywords: {', '.join(keywords)} over {timeframe}.
+
+            Provide insights on:
+            1. Overall trend momentum and direction
+            2. Investment themes and opportunities
+            3. Risk factors and market dynamics
+            4. Implications for startups in these sectors
+
+            Keep insights concise and actionable.
+            """
+
+            user_prompt = f"""
+            Keywords: {keywords}
+            Timeframe: {timeframe}
+
+            Trend Performance Data:
+            {json.dumps(trend_data, indent=2)}
+
+            Provide trend analysis with startup implications.
+            """
+
+            response = await self.client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=400,
+                temperature=0.3
+            )
+
+            return response.choices[0].message.content
+
+        except Exception as e:
+            logger.error(f"Error generating trend insights: {e}")
+            return "Trend insights temporarily unavailable."
+
+    def _is_cache_valid(self, cache_key: str) -> bool:
+        """Check if cached data is still valid"""
+        if cache_key not in self.cache_expiry:
+            return False
+        return datetime.now() < self.cache_expiry[cache_key]
+
+    def _cache_data(self, cache_key: str, data: Any, hours: int = 1):
+        """Cache data with expiry"""
+        self.data_cache[cache_key] = data
+        self.cache_expiry[cache_key] = datetime.now() + timedelta(hours=hours)
+
+class DashboardVisualizer:
+    """Creates interactive visualizations for market intelligence dashboard"""
+
+    def __init__(self):
+        self.theme_colors = {
+            "primary": "#667eea",
+            "secondary": "#764ba2",
+            "success": "#4CAF50",
+            "danger": "#f44336",
+            "warning": "#ff9800",
+            "info": "#2196F3"
+        }
+
+    def create_market_overview_chart(self, market_data: Dict[str, Any]) -> str:
+        """Create market overview visualization"""
+        try:
+            symbols = list(market_data["market_data"].keys())
+            names = [data["name"] for data in market_data["market_data"].values()]
+            ytd_changes = [data["ytd_change"] for data in market_data["market_data"].values()]
+
+            # Create bar chart
+            fig = go.Figure()
+
+            colors = [self.theme_colors["success"] if change >= 0 else self.theme_colors["danger"]
+                     for change in ytd_changes]
+
+            fig.add_trace(go.Bar(
+                x=symbols,
+                y=ytd_changes,
+                text=[f"{change:.1f}%" for change in ytd_changes],
+                textposition='auto',
+                marker_color=colors,
+                hovertemplate='<b>%{x}</b><br>YTD Change: %{y:.1f}%<extra></extra>'
+            ))
+
+            fig.update_layout(
+                title=f"{market_data['sector'].title()} Sector Performance (YTD)",
+                xaxis_title="ETFs/Indices",
+                yaxis_title="YTD Change (%)",
+                template="plotly_white",
+                font=dict(family="Inter, sans-serif"),
+                height=400
+            )
+
+            return fig.to_html(include_plotlyjs=True, div_id="market-overview-chart")
+
+        except Exception as e:
+            logger.error(f"Error creating market overview chart: {e}")
+            return "<div>Error creating market overview chart</div>"
+
+    def create_competitive_comparison(self, competitive_data: Dict[str, Any]) -> str:
+        """Create competitive landscape comparison"""
+        try:
+            competitors = competitive_data["competitors"]
+            if not competitors:
+                return "<div>No competitive data available</div>"
+
+            # Create subplot with multiple metrics
+            fig = make_subplots(
+                rows=2, cols=2,
+                subplot_titles=('Market Cap', 'Revenue Growth', 'Profit Margin', 'P/E Ratio'),
+                specs=[[{"secondary_y": False}, {"secondary_y": False}],
+                       [{"secondary_y": False}, {"secondary_y": False}]]
+            )
+
+            symbols = list(competitors.keys())
+            market_caps = [competitors[s].get('market_cap', 0) / 1e9 for s in symbols]  # In billions
+            revenue_growth = [competitors[s].get('revenue_growth', 0) * 100 for s in symbols]
+            profit_margins = [competitors[s].get('profit_margin', 0) * 100 for s in symbols]
+            pe_ratios = [competitors[s].get('pe_ratio', 0) for s in symbols]
+
+            # Market Cap
+            fig.add_trace(go.Bar(x=symbols, y=market_caps, name="Market Cap (B)",
+                               marker_color=self.theme_colors["primary"]), row=1, col=1)
+
+            # Revenue Growth
+            fig.add_trace(go.Bar(x=symbols, y=revenue_growth, name="Revenue Growth (%)",
+                               marker_color=self.theme_colors["success"]), row=1, col=2)
+
+            # Profit Margin
+            fig.add_trace(go.Bar(x=symbols, y=profit_margins, name="Profit Margin (%)",
+                               marker_color=self.theme_colors["info"]), row=2, col=1)
+
+            # P/E Ratio
+            fig.add_trace(go.Bar(x=symbols, y=pe_ratios, name="P/E Ratio",
+                               marker_color=self.theme_colors["warning"]), row=2, col=2)
+
+            fig.update_layout(
+                title="Competitive Landscape Analysis",
+                template="plotly_white",
+                font=dict(family="Inter, sans-serif"),
+                height=600,
+                showlegend=False
+            )
+
+            return fig.to_html(include_plotlyjs=True, div_id="competitive-chart")
+
+        except Exception as e:
+            logger.error(f"Error creating competitive comparison: {e}")
+            return "<div>Error creating competitive comparison</div>"
+
+    def create_trend_heatmap(self, trend_data: Dict[str, Any]) -> str:
+        """Create trend analysis heatmap"""
+        try:
+            keywords = trend_data["keywords"]
+            trends = trend_data["trend_data"]
+
+            if not trends:
+                return "<div>No trend data available</div>"
+
+            # Prepare data for heatmap
+            symbols = set()
+            for keyword_data in trends.values():
+                symbols.update(keyword_data.keys())
+
+            symbols = list(symbols)
+            performance_matrix = []
+
+            for keyword in keywords:
+                row = []
+                for symbol in symbols:
+                    performance = trends.get(keyword, {}).get(symbol, {}).get('performance', 0)
+                    row.append(performance)
+                performance_matrix.append(row)
+
+            # Create heatmap
+            fig = go.Figure(data=go.Heatmap(
+                z=performance_matrix,
+                x=symbols,
+                y=keywords,
+                colorscale='RdYlGn',
+                text=[[f"{val:.1f}%" for val in row] for row in performance_matrix],
+                texttemplate="%{text}",
+                textfont={"size": 10},
+                hoverongaps=False
+            ))
+
+            fig.update_layout(
+                title=f"Trend Performance Heatmap ({trend_data['timeframe']})",
+                xaxis_title="Symbols",
+                yaxis_title="Keywords",
+                template="plotly_white",
+                font=dict(family="Inter, sans-serif"),
+                height=400
+            )
+
+            return fig.to_html(include_plotlyjs=True, div_id="trend-heatmap")
+
+        except Exception as e:
+            logger.error(f"Error creating trend heatmap: {e}")
+            return "<div>Error creating trend heatmap</div>"
+
+class MarketIntelligenceDashboard:
+    """Main dashboard class that orchestrates market intelligence features"""
+
+    def __init__(self):
+        self.engine = MarketIntelligenceEngine()
+        self.visualizer = DashboardVisualizer()
+
+    async def create_dashboard_interface(self) -> str:
+        """Create the main dashboard HTML interface"""
+        return """
+        <div id="market-intelligence-dashboard" class="dashboard-container">
+            <div class="dashboard-header">
+                <h1>📊 Market Intelligence Dashboard</h1>
+                <p>Real-time market data, competitive intelligence, and trend analysis</p>
+            </div>
+
+            <div class="dashboard-controls">
+                <div class="control-group">
+                    <label>Sector Analysis:</label>
+                    <select id="sector-select">
+                        <option value="technology">Technology</option>
+                        <option value="healthcare">Healthcare</option>
+                        <option value="finance">Finance</option>
+                        <option value="energy">Energy</option>
+                        <option value="retail">Retail</option>
+                    </select>
+                    <button onclick="loadMarketOverview()" class="dashboard-btn">Analyze Sector</button>
+                </div>
+
+                <div class="control-group">
+                    <label>Competitive Analysis:</label>
+                    <input type="text" id="company-input" placeholder="Company name" />
+                    <input type="text" id="industry-input" placeholder="Industry" />
+                    <button onclick="loadCompetitiveAnalysis()" class="dashboard-btn">Analyze Competition</button>
+                </div>
+
+                <div class="control-group">
+                    <label>Trend Analysis:</label>
+                    <input type="text" id="keywords-input" placeholder="Keywords (comma-separated)" />
+                    <select id="timeframe-select">
+                        <option value="1y">1 Year</option>
+                        <option value="6mo">6 Months</option>
+                        <option value="3mo">3 Months</option>
+                        <option value="1mo">1 Month</option>
+                    </select>
+                    <button onclick="loadTrendAnalysis()" class="dashboard-btn">Analyze Trends</button>
+                </div>
+            </div>
+
+            <div class="dashboard-content">
+                <div id="market-overview-section" class="dashboard-section">
+                    <h2>Market Overview</h2>
+                    <div id="market-overview-chart"></div>
+                    <div id="market-insights" class="insights-panel"></div>
+                </div>
+
+                <div id="competitive-section" class="dashboard-section">
+                    <h2>Competitive Landscape</h2>
+                    <div id="competitive-chart"></div>
+                    <div id="competitive-insights" class="insights-panel"></div>
+                </div>
+
+                <div id="trends-section" class="dashboard-section">
+                    <h2>Market Trends</h2>
+                    <div id="trend-heatmap"></div>
+                    <div id="trend-insights" class="insights-panel"></div>
+                </div>
+            </div>
+
+            <div class="dashboard-footer">
+                <p>Last updated: <span id="last-updated">Never</span></p>
+                <button onclick="refreshAllData()" class="refresh-btn">🔄 Refresh All Data</button>
+            </div>
+        </div>
+
+        <style>
+        .dashboard-container {
+            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+            border-radius: 20px;
+            padding: 30px;
+            margin: 20px 0;
+            font-family: 'Inter', sans-serif;
+        }
+
+        .dashboard-header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+
+        .dashboard-header h1 {
+            color: #2d3748;
+            margin-bottom: 10px;
+        }
+
+        .dashboard-controls {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+            padding: 20px;
+            background: white;
+            border-radius: 15px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        .control-group {
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+        }
+
+        .control-group label {
+            font-weight: 600;
+            color: #4a5568;
+        }
+
+        .control-group input,
+        .control-group select {
+            padding: 10px;
+            border: 2px solid #e2e8f0;
+            border-radius: 8px;
+            font-size: 14px;
+        }
+
+        .dashboard-btn {
+            padding: 12px 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 8px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: opacity 0.3s ease;
+        }
+
+        .dashboard-btn:hover {
+            opacity: 0.9;
+        }
+
+        .dashboard-content {
+            display: flex;
+            flex-direction: column;
+            gap: 30px;
+        }
+
+        .dashboard-section {
+            background: white;
+            border-radius: 15px;
+            padding: 25px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        .dashboard-section h2 {
+            color: #2d3748;
+            margin-bottom: 20px;
+            padding-bottom: 10px;
+            border-bottom: 2px solid #e2e8f0;
+        }
+
+        .insights-panel {
+            background: #f7fafc;
+            border-radius: 10px;
+            padding: 20px;
+            margin-top: 20px;
+            border-left: 4px solid #667eea;
+        }
+
+        .dashboard-footer {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-top: 30px;
+            padding: 20px;
+            background: rgba(255, 255, 255, 0.8);
+            border-radius: 10px;
+        }
+
+        .refresh-btn {
+            padding: 10px 20px;
+            background: #4CAF50;
+            color: white;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            font-weight: 600;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #718096;
+        }
+
+        .error {
+            background: #fed7d7;
+            color: #c53030;
+            padding: 15px;
+            border-radius: 8px;
+            margin: 10px 0;
+        }
+        </style>
+
+        <script>
+        async function loadMarketOverview() {
+            const sector = document.getElementById('sector-select').value;
+            const chartDiv = document.getElementById('market-overview-chart');
+            const insightsDiv = document.getElementById('market-insights');
+
+            chartDiv.innerHTML = '<div class="loading">Loading market overview...</div>';
+            insightsDiv.innerHTML = '';
+
+            try {
+                const response = await sendDashboardRequest('market_overview', { sector });
+                if (response.status === 'success') {
+                    chartDiv.innerHTML = response.chart;
+                    insightsDiv.innerHTML = `<h3>Market Insights</h3><p>${response.insights}</p>`;
+                    updateLastUpdated();
+                } else {
+                    chartDiv.innerHTML = `<div class="error">Error: ${response.message}</div>`;
+                }
+            } catch (error) {
+                chartDiv.innerHTML = `<div class="error">Error loading market data</div>`;
+            }
+        }
+
+        async function loadCompetitiveAnalysis() {
+            const company = document.getElementById('company-input').value;
+            const industry = document.getElementById('industry-input').value;
+
+            if (!company || !industry) {
+                alert('Please enter both company name and industry');
+                return;
+            }
+
+            const chartDiv = document.getElementById('competitive-chart');
+            const insightsDiv = document.getElementById('competitive-insights');
+
+            chartDiv.innerHTML = '<div class="loading">Loading competitive analysis...</div>';
+            insightsDiv.innerHTML = '';
+
+            try {
+                const response = await sendDashboardRequest('competitive_analysis', { company, industry });
+                if (response.status === 'success') {
+                    chartDiv.innerHTML = response.chart;
+                    insightsDiv.innerHTML = `<h3>Competitive Analysis</h3><p>${response.analysis}</p>`;
+                    updateLastUpdated();
+                } else {
+                    chartDiv.innerHTML = `<div class="error">Error: ${response.message}</div>`;
+                }
+            } catch (error) {
+                chartDiv.innerHTML = `<div class="error">Error loading competitive data</div>`;
+            }
+        }
+
+        async function loadTrendAnalysis() {
+            const keywordsInput = document.getElementById('keywords-input').value;
+            const timeframe = document.getElementById('timeframe-select').value;
+
+            if (!keywordsInput) {
+                alert('Please enter keywords for trend analysis');
+                return;
+            }
+
+            const keywords = keywordsInput.split(',').map(k => k.trim());
+            const chartDiv = document.getElementById('trend-heatmap');
+            const insightsDiv = document.getElementById('trend-insights');
+
+            chartDiv.innerHTML = '<div class="loading">Loading trend analysis...</div>';
+            insightsDiv.innerHTML = '';
+
+            try {
+                const response = await sendDashboardRequest('trend_analysis', { keywords, timeframe });
+                if (response.status === 'success') {
+                    chartDiv.innerHTML = response.chart;
+                    insightsDiv.innerHTML = `<h3>Trend Insights</h3><p>${response.insights}</p>`;
+                    updateLastUpdated();
+                } else {
+                    chartDiv.innerHTML = `<div class="error">Error: ${response.message}</div>`;
+                }
+            } catch (error) {
+                chartDiv.innerHTML = `<div class="error">Error loading trend data</div>`;
+            }
+        }
+
+        async function refreshAllData() {
+            await loadMarketOverview();
+            if (document.getElementById('company-input').value && document.getElementById('industry-input').value) {
+                await loadCompetitiveAnalysis();
+            }
+            if (document.getElementById('keywords-input').value) {
+                await loadTrendAnalysis();
+            }
+        }
+
+        async function sendDashboardRequest(type, data) {
+            if (window.chainlitAPI) {
+                return await window.chainlitAPI.sendMessage({
+                    type: 'dashboard_request',
+                    request_type: type,
+                    data: data
+                });
+            }
+            throw new Error('Chainlit API not available');
+        }
+
+        function updateLastUpdated() {
+            document.getElementById('last-updated').textContent = new Date().toLocaleString();
+        }
+
+        // Auto-load technology sector overview on page load
+        document.addEventListener('DOMContentLoaded', function() {
+            setTimeout(loadMarketOverview, 1000);
+        });
+        </script>
+        """
+
+    async def handle_dashboard_request(self, request_type: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle different types of dashboard requests"""
+        try:
+            if request_type == "market_overview":
+                sector = data.get("sector", "technology")
+                market_data = await self.engine.get_market_overview(sector)
+
+                if "status" in market_data and market_data["status"] == "error":
+                    return market_data
+
+                chart_html = self.visualizer.create_market_overview_chart(market_data)
+
+                return {
+                    "status": "success",
+                    "chart": chart_html,
+                    "insights": market_data["insights"],
+                    "data": market_data
+                }
+
+            elif request_type == "competitive_analysis":
+                company = data.get("company", "")
+                industry = data.get("industry", "")
+
+                competitive_data = await self.engine.get_competitive_landscape(company, industry)
+
+                if "status" in competitive_data and competitive_data["status"] == "error":
+                    return competitive_data
+
+                chart_html = self.visualizer.create_competitive_comparison(competitive_data)
+
+                return {
+                    "status": "success",
+                    "chart": chart_html,
+                    "analysis": competitive_data["analysis"],
+                    "data": competitive_data
+                }
+
+            elif request_type == "trend_analysis":
+                keywords = data.get("keywords", [])
+                timeframe = data.get("timeframe", "1y")
+
+                trend_data = await self.engine.get_trend_analysis(keywords, timeframe)
+
+                if "status" in trend_data and trend_data["status"] == "error":
+                    return trend_data
+
+                chart_html = self.visualizer.create_trend_heatmap(trend_data)
+
+                return {
+                    "status": "success",
+                    "chart": chart_html,
+                    "insights": trend_data["insights"],
+                    "data": trend_data
+                }
+
+            else:
+                return {"status": "error", "message": "Unknown request type"}
+
+        except Exception as e:
+            logger.error(f"Error handling dashboard request: {e}")
+            return {"status": "error", "message": str(e)}