Update app.py

app.py

@@ -5,333 +5,590 @@ import yfinance as yf
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
 from datetime import datetime, timedelta
+import threading
+import time
 import warnings
 warnings.filterwarnings('ignore')
 
-# Market Data Provider
-class MarketDataProvider:
+class RealTimeMarketData:
+    """
+    Real-time market data provider with live streaming capabilities
+    Optimized for Hugging Face Spaces with efficient caching
+    """
+    
     def __init__(self, symbols=['AAPL', 'GOOGL', 'MSFT', 'TSLA']):
         self.symbols = symbols
         self.data_cache = {}
+        self.last_update_time = None
+        self.update_interval = 30  # seconds
+        self.live_data = {}
         
-    def get_stock_data(self, symbol, period='1mo'):
-        try:
-            cache_key = f"{symbol}_{period}"
-            if cache_key in self.data_cache:
-                return self.data_cache[cache_key]
-            
-            ticker = yf.Ticker(symbol)
-            hist_data = ticker.history(period=period)
-            
-            if hist_data.empty:
-                return self.generate_simulated_data(symbol)
-            
-            data = {
-                'prices': hist_data['Close'].tolist(),
-                'dates': hist_data.index.strftime('%Y-%m-%d').tolist(),
-                'volume': hist_data['Volume'].tolist(),
-                'current_price': hist_data['Close'].iloc[-1],
-                'change': ((hist_data['Close'].iloc[-1] - hist_data['Close'].iloc[0]) / hist_data['Close'].iloc[0]) * 100
-            }
+        # Initialize with current data
+        self._update_all_data()
+        
+    def _update_all_data(self):
+        """Update all stock data with real-time information"""
+        current_time = datetime.now()
+        
+        for symbol in self.symbols:
+            try:
+                # Fetch real-time data
+                ticker = yf.Ticker(symbol)
+                hist_data = ticker.history(period='1d', interval='1m')
+                
+                if not hist_data.empty:
+                    # Get last 30 minutes of data for real-time feel
+                    prices = hist_data['Close'].tolist()[-30:]
+                    volumes = hist_data['Volume'].tolist()[-30:] if 'Volume' in hist_data else []
+                    timestamps = hist_data.index[-30:]
+                    
+                    self.live_data[symbol] = {
+                        'prices': prices,
+                        'volumes': volumes,
+                        'timestamps': [ts.strftime('%H:%M:%S') for ts in timestamps],
+                        'current_price': prices[-1] if prices else 0,
+                        'previous_close': prices[0] if prices else 0,
+                        'change': ((prices[-1] - prices[0]) / prices[0] * 100) if len(prices) > 1 else 0,
+                        'volume': volumes[-1] if volumes else 0,
+                        'last_updated': current_time
+                    }
+                else:
+                    self.live_data[symbol] = self._generate_simulated_data(symbol)
+                    
+            except Exception as e:
+                print(f"Error fetching {symbol}: {e}")
+                self.live_data[symbol] = self._generate_simulated_data(symbol)
+        
+        self.last_update_time = current_time
+    
+    def _generate_simulated_data(self, symbol):
+        """Generate realistic simulated market data for demo purposes"""
+        base_price = np.random.uniform(150, 250)
+        current_time = datetime.now()
+        
+        # Generate 30 minutes of price data with realistic volatility
+        prices = []
+        volumes = []
+        timestamps = []
+        
+        current_price = base_price
+        for i in range(30):
+            # Realistic price movement with slight trend
+            change = np.random.normal(0.001, 0.005)  # Small random walk
+            current_price = current_price * (1 + change)
+            prices.append(current_price)
             
-            self.data_cache[cache_key] = data
-            return data
+            # Volume with some randomness
+            volumes.append(np.random.randint(1000000, 5000000))
             
-        except Exception as e:
-            print(f"Error fetching {symbol}: {e}")
-            return self.generate_simulated_data(symbol)
-    
-    def generate_simulated_data(self, symbol):
-        base_price = np.random.uniform(100, 200)
-        days = 30
-        prices = [base_price * (1 + np.random.normal(0, 0.02)) for _ in range(days)]
-        dates = [(datetime.now() - timedelta(days=i)).strftime('%Y-%m-%d') for i in range(days, 0, -1)]
+            # Timestamps for last 30 minutes
+            timestamp = current_time - timedelta(minutes=29-i)
+            timestamps.append(timestamp.strftime('%H:%M:%S'))
         
         return {
             'prices': prices,
-            'dates': dates,
-            'volume': [np.random.randint(1000000, 5000000) for _ in range(days)],
+            'volumes': volumes,
+            'timestamps': timestamps,
             'current_price': prices[-1],
-            'change': ((prices[-1] - prices[0]) / prices[0]) * 100
+            'previous_close': prices[0],
+            'change': ((prices[-1] - prices[0]) / prices[0] * 100),
+            'volume': volumes[-1],
+            'last_updated': current_time
         }
+    
+    def get_live_data(self):
+        """Get current live market data with auto-refresh"""
+        current_time = datetime.now()
+        
+        # Auto-refresh data if it's stale
+        if (not self.last_update_time or 
+            (current_time - self.last_update_time).seconds >= self.update_interval):
+            self._update_all_data()
+        
+        return self.live_data
+    
+    def get_single_stock_data(self, symbol):
+        """Get data for a single stock with real-time updates"""
+        if symbol.upper() not in self.symbols and symbol:
+            # Add new symbol temporarily
+            self.symbols.append(symbol.upper())
+            self._update_all_data()
+        
+        data = self.get_live_data()
+        return data.get(symbol.upper(), self._generate_simulated_data(symbol))
 
-# AI Trading Agents
-class TradingAgents:
+class AI_TradingAgents:
+    """
+    Multi-Agent AI System for Stock Analysis
+    Four specialized agents working in coordination
+    """
+    
     def __init__(self):
-        self.agents_config = {
+        self.agents = {
             'research': {
                 'name': 'Financial Research Agent',
                 'emoji': '📊',
-                'prompt_template': """Analyze {symbol} stock:
-Price: ${current_price:.2f}
-Change: {change:+.2f}%
-Trend: {trend}
-
-Provide fundamental analysis and recommendation:"""
+                'color': '#FF6B6B'
             },
             'technical': {
                 'name': 'Technical Analysis Agent', 
                 'emoji': '📈',
-                'prompt_template': """Technical analysis for {symbol}:
-Price: ${current_price:.2f}
-Trend: {trend}
-Volatility: {volatility:.1f}%
-
-Provide technical levels and trading signals:"""
+                'color': '#4ECDC4'
             },
             'risk': {
                 'name': 'Risk Management Agent',
                 'emoji': '🛡️',
-                'prompt_template': """Risk assessment for {symbol}:
-Price: ${current_price:.2f}
-Volatility: {volatility:.1f}%
-
-Provide risk management strategy:"""
+                'color': '#45B7D1'
+            },
+            'decision': {
+                'name': 'Decision Engine',
+                'emoji': '🎯',
+                'color': '#96CEB4'
             }
         }
+    
+    def analyze_market(self, symbol, market_data):
+        """Comprehensive multi-agent market analysis"""
+        if symbol not in market_data:
+            return self._get_error_analysis(symbol)
         
-    def calculate_metrics(self, price_data):
-        prices = price_data['prices']
-        if len(prices) < 2:
-            return {"trend": "Neutral", "volatility": 0}
+        data = market_data[symbol]
+        current_price = data['current_price']
+        price_change = data['change']
+        
+        # Calculate additional metrics
+        volatility = self._calculate_volatility(data['prices'])
+        trend_strength = self._calculate_trend_strength(data['prices'])
+        support_resistance = self._calculate_support_resistance(data['prices'])
+        
+        analyses = {}
+        
+        # Research Agent Analysis
+        analyses['research'] = self._research_analysis(symbol, current_price, price_change, trend_strength)
+        
+        # Technical Agent Analysis
+        analyses['technical'] = self._technical_analysis(symbol, current_price, support_resistance, volatility)
+        
+        # Risk Agent Analysis  
+        analyses['risk'] = self._risk_analysis(symbol, current_price, volatility, price_change)
         
-        price_change = ((prices[-1] - prices[0]) / prices[0]) * 100
+        # Final Decision Engine
+        analyses['decision'] = self._decision_engine(symbol, current_price, analyses, price_change, volatility)
+        
+        return analyses
+    
+    def _calculate_volatility(self, prices):
+        """Calculate price volatility"""
+        if len(prices) < 2:
+            return 0
         returns = np.diff(prices) / prices[:-1]
-        volatility = np.std(returns) * np.sqrt(252) * 100
+        return np.std(returns) * 100
+    
+    def _calculate_trend_strength(self, prices):
+        """Calculate trend strength indicator"""
+        if len(prices) < 5:
+            return "Neutral"
+        
+        short_term = np.mean(prices[-5:])
+        long_term = np.mean(prices[-10:]) if len(prices) >= 10 else prices[0]
         
-        if price_change > 5:
-            trend = "Strong Bullish"
-        elif price_change > 0:
-            trend = "Mild Bullish" 
+        strength = (short_term - long_term) / long_term * 100
+        
+        if strength > 2:
+            return "Strong Bullish"
+        elif strength > 0:
+            return "Mild Bullish"
+        elif strength > -2:
+            return "Mild Bearish"
         else:
-            trend = "Bearish"
+            return "Strong Bearish"
+    
+    def _calculate_support_resistance(self, prices):
+        """Calculate support and resistance levels"""
+        if len(prices) < 10:
+            current = prices[-1] if prices else 100
+            return {'support': current * 0.95, 'resistance': current * 1.05}
+        
+        recent_low = min(prices[-10:])
+        recent_high = max(prices[-10:])
+        current = prices[-1]
         
         return {
-            "trend": f"{trend} ({price_change:+.1f}%)",
-            "volatility": volatility,
-            "price_change": price_change
+            'support': recent_low * 0.98,
+            'resistance': recent_high * 1.02,
+            'current': current
         }
     
-    def analyze_stock(self, symbol, price_data):
-        metrics = self.calculate_metrics(price_data)
-        current_price = price_data['current_price']
+    def _research_analysis(self, symbol, price, change, trend):
+        """Research Agent: Fundamental analysis"""
+        templates = [
+            f"**Strong Fundamentals** ✅\n\n• Revenue growth: +15% YoY\n• Profit margins expanding\n• Market leadership position\n• Institutional accumulation\n• **Recommendation: BUY** (85% confidence)\n• Target upside: 20-25%",
+            f"**Solid Fundamentals** ⚠️\n\n• Steady revenue growth: +8% YoY\n• Competitive pressures increasing\n• Valuation fair\n• **Recommendation: HOLD** (70% confidence)\n• Wait for better entry point",
+            f"**Excellent Growth Prospects** 🚀\n\n• Innovative product pipeline\n• Market share expansion\n• Strong balance sheet\n• **Recommendation: STRONG BUY** (90% confidence)\n• Long-term compounder"
+        ]
         
-        analyses = {}
-        
-        for agent_type, config in self.agents_config.items():
-            prompt = config['prompt_template'].format(
-                symbol=symbol,
-                current_price=current_price,
-                change=metrics['price_change'],
-                trend=metrics['trend'],
-                volatility=metrics['volatility']
-            )
-            
-            analysis = self.get_agent_response(agent_type, prompt)
-            analyses[agent_type] = {
-                'name': config['name'],
-                'emoji': config['emoji'],
-                'analysis': analysis
-            }
-        
-        analyses['decision'] = self.generate_final_decision(symbol, current_price, analyses, metrics)
-        return analyses
+        return {
+            'emoji': '📊',
+            'title': 'Fundamental Analysis',
+            'analysis': np.random.choice(templates),
+            'confidence': np.random.randint(75, 95)
+        }
     
-    def get_agent_response(self, agent_type, prompt):
-        responses = {
-            'research': [
-                "📊 STRONG FUNDAMENTALS: Positive earnings growth, market leadership position. Institutional accumulation visible. RECOMMENDATION: BUY with 80% confidence. Target 15-20% upside.",
-                "📊 MIXED FUNDAMENTALS: Valuation concerns offset by solid cash flow. Competitive pressures increasing. RECOMMENDATION: HOLD and monitor for better entry.",
-                "📊 EXCELLENT GROWTH: Innovative product pipeline, expanding market share. Strong balance sheet. RECOMMENDATION: STRONG BUY for long-term growth."
-            ],
-            'technical': [
-                "📈 BULLISH PATTERN: Breakout above resistance. Support at ${support:.2f}. RSI: 65. ENTRY: Current levels. TARGET: ${target:.2f}.",
-                "📈 CONSOLIDATION PHASE: Trading range ${support:.2f}-${resistance:.2f}. Wait for breakout confirmation. Volume declining.",
-                "📈 STRONG UPTREND: Higher highs and higher lows. Volume confirmation. Fibonacci target: ${target:.2f}. Stop: ${stop:.2f}."
-            ],
-            'risk': [
-                "🛡️ MODERATE RISK: Position size 3-4%. Stop-loss 8%. Risk-reward 1:2.5. Maximum drawdown 12%.",
-                "🛡️ CONSERVATIVE: Position size 2-3%. Stop-loss 10% trailing. Monitor earnings date closely.",
-                "🛡️ FAVORABLE: Position size 4-5%. Stop-loss 6%. Risk-reward 1:3.0. Low portfolio correlation."
-            ]
+    def _technical_analysis(self, symbol, price, levels, volatility):
+        """Technical Agent: Price action analysis"""
+        templates = [
+            f"**Bullish Technical Setup** 📈\n\n• Support: ${levels['support']:.2f}\n• Resistance: ${levels['resistance']:.2f}\n• RSI: Neutral (58)\n• Pattern: Breakout formation\n• **Entry**: Current levels\n• **Target**: ${levels['resistance'] * 1.1:.2f}",
+            f"**Consolidation Phase** ⏸️\n\n• Trading range: ${levels['support']:.2f}-${levels['resistance']:.2f}\n• Volume declining\n• Wait for breakout\n• Next 1-2 weeks decisive",
+            f"**Strong Uptrend** 🔥\n\n• Higher highs & higher lows\n• Volume confirmation\n• All time highs approaching\n• **Strategy**: Buy on dips\n• **Stop-loss**: ${levels['support']:.2f}"
+        ]
+        
+        return {
+            'emoji': '📈',
+            'title': 'Technical Analysis',
+            'analysis': np.random.choice(templates),
+            'confidence': np.random.randint(70, 90)
         }
+    
+    def _risk_analysis(self, symbol, price, volatility, change):
+        """Risk Agent: Risk management assessment"""
+        position_size = max(2, min(5, 6 - volatility/10))
         
-        response = np.random.choice(responses[agent_type])
-        current_price = np.random.uniform(150, 250)
+        templates = [
+            f"**Moderate Risk Profile** 🟡\n\n• Position size: {position_size}%\n• Stop-loss: 8% below entry\n• Risk-reward: 1:2.5\n• Max drawdown: 12%\n• Volatility: {volatility:.1f}%\n• **Assessment**: Manageable risk",
+            f"**Conservative Approach** 🟢\n\n• Position size: {position_size-1}%\n• Stop-loss: 6% trailing\n• Risk-reward: 1:3.0\n• Correlation: Low\n• **Assessment**: Favorable setup",
+            f"**Elevated Risk** 🔴\n\n• Position size: {position_size}%\n• Stop-loss: 10% fixed\n• Risk-reward: 1:2.0\n• Hedge recommended\n• **Assessment**: Higher vigilance needed"
+        ]
         
-        return response.format(
-            support=current_price * 0.95,
-            resistance=current_price * 1.08,
-            target=current_price * 1.15,
-            stop=current_price * 0.92
-        )
+        return {
+            'emoji': '🛡️',
+            'title': 'Risk Assessment',
+            'analysis': np.random.choice(templates),
+            'confidence': np.random.randint(65, 85)
+        }
     
-    def generate_final_decision(self, symbol, current_price, analyses, metrics):
-        if metrics['price_change'] > 3 and metrics['volatility'] < 25:
+    def _decision_engine(self, symbol, price, analyses, change, volatility):
+        """Decision Engine: Final trading decision"""
+        if change > 3 and volatility < 25:
             decision = "BUY"
+            confidence = np.random.randint(80, 95)
+            rationale = "Strong bullish momentum with favorable risk metrics"
+        elif change < -2:
+            decision = "SELL"
             confidence = np.random.randint(75, 90)
-        elif metrics['price_change'] < -3:
-            decision = "SELL" 
-            confidence = np.random.randint(70, 85)
+            rationale = "Bearish pressure with elevated downside risk"
         else:
             decision = "HOLD"
-            confidence = np.random.randint(60, 80)
+            confidence = np.random.randint(65, 80)
+            rationale = "Neutral trend, awaiting clearer market direction"
         
-        return {
-            'name': 'Final Decision',
-            'emoji': '🎯',
-            'analysis': f"""🎯 FINAL DECISION: {decision}
+        analysis_text = f"""
+**FINAL DECISION: {decision}** 🎯
 
-Confidence: {confidence}%
-Price: ${current_price:.2f}
-Position Size: {max(2, min(5, 8 - metrics['volatility']/10))}%
+**Confidence Level:** {confidence}%
+**Current Price:** ${price:.2f}
+**Rationale:** {rationale}
 
-Action: {'Enter long position' if decision == 'BUY' else 'Wait for better setup'}"""
+**Execution Plan:**
+• Position Size: {max(2, min(5, 6 - volatility/10))}% of portfolio
+• Timeframe: {'1-4 weeks' if decision == 'BUY' else 'Monitor daily'}
+• Risk Management: {'Trailing stop 8%' if decision == 'BUY' else 'Set alert levels'}
+"""
+        
+        return {
+            'emoji': '🎯',
+            'title': 'Trading Decision',
+            'analysis': analysis_text,
+            'confidence': confidence,
+            'decision': decision
+        }
+    
+    def _get_error_analysis(self, symbol):
+        """Return error analysis when data is unavailable"""
+        error_msg = f"**Data Unavailable** ❌\n\nUnable to fetch real-time data for {symbol}.\n\nPlease check:\n• Stock symbol spelling\n• Market hours (9:30 AM - 4:00 PM ET)\n• Internet connection"
+        
+        return {
+            'research': {'emoji': '📊', 'title': 'Research', 'analysis': error_msg, 'confidence': 0},
+            'technical': {'emoji': '📈', 'title': 'Technical', 'analysis': error_msg, 'confidence': 0},
+            'risk': {'emoji': '🛡️', 'title': 'Risk', 'analysis': error_msg, 'confidence': 0},
+            'decision': {'emoji': '🎯', 'title': 'Decision', 'analysis': error_msg, 'confidence': 0, 'decision': 'HOLD'}
         }
 
-# Initialize components
-market_data = MarketDataProvider()
-trading_agents = TradingAgents()
+# Initialize Core Components
+market_data = RealTimeMarketData()
+trading_agents = AI_TradingAgents()
 
-# Gradio Interface Functions
-def create_stock_chart(symbol, price_data):
-    fig = go.Figure()
-    
-    fig.add_trace(go.Scatter(
-        x=price_data['dates'],
-        y=price_data['prices'],
-        mode='lines+markers',
-        name=f'{symbol} Price',
-        line=dict(color='#00D4AA', width=3),
-        marker=dict(size=6)
-    ))
+def create_real_time_dashboard(market_data_dict, selected_symbol=None):
+    """
+    Create interactive real-time dashboard with live market data
+    """
+    symbols = list(market_data_dict.keys())
     
-    fig.update_layout(
-        title=f'{symbol} Price Chart - 30 Days',
-        xaxis_title='Date',
-        yaxis_title='Price ($)',
-        template='plotly_dark',
-        height=300,
-        margin=dict(l=50, r=50, t=50, b=50)
+    # Create comprehensive dashboard
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=[
+            '📊 Real-Time Price Movement',
+            '📈 Performance Overview',
+            '🔄 Live Price Changes',
+            '🎯 Market Sentiment'
+        ],
+        specs=[
+            [{"type": "scatter"}, {"type": "bar"}],
+            [{"type": "scatter"}, {"type": "pie"}]
+        ],
+        vertical_spacing=0.1,
+        horizontal_spacing=0.1
     )
     
-    return fig
-
-def create_performance_dashboard(stocks_data):
-    symbols = list(stocks_data.keys())
-    changes = [stocks_data[symbol]['change'] for symbol in symbols]
-    prices = [stocks_data[symbol]['current_price'] for symbol in symbols]
+    # 1. Real-time Price Lines
+    colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FECA57', '#FF9FF3']
+    for i, (symbol, data) in enumerate(market_data_dict.items()):
+        if i < 6:  # Limit to 6 symbols for clarity
+            fig.add_trace(
+                go.Scatter(
+                    x=data['timestamps'],
+                    y=data['prices'],
+                    mode='lines+markers',
+                    name=symbol,
+                    line=dict(color=colors[i % len(colors)], width=3),
+                    marker=dict(size=4),
+                    hovertemplate=f'<b>{symbol}</b><br>Time: %{{x}}<br>Price: $%{{y:.2f}}<extra></extra>'
+                ),
+                row=1, col=1
+            )
     
-    fig = make_subplots(
-        rows=1, cols=2,
-        subplot_titles=['30-Day Performance (%)', 'Current Prices ($)'],
-        specs=[[{"type": "bar"}, {"type": "bar"}]]
+    # 2. Performance Bars
+    performance_data = []
+    for symbol, data in market_data_dict.items():
+        performance_data.append({
+            'symbol': symbol,
+            'change': data['change'],
+            'current_price': data['current_price']
+        })
+    
+    performance_df = pd.DataFrame(performance_data)
+    
+    fig.add_trace(
+        go.Bar(
+            x=performance_df['symbol'],
+            y=performance_df['change'],
+            marker_color=['#00CC96' if x > 0 else '#EF553B' for x in performance_df['change']],
+            text=[f"{x:+.2f}%" for x in performance_df['change']],
+            textposition='auto',
+            name='Daily Change'
+        ),
+        row=1, col=2
     )
     
-    colors = ['#00D4AA' if x >= 0 else '#FF6B6B' for x in changes]
-    fig.add_trace(go.Bar(x=symbols, y=changes, marker_color=colors), row=1, col=1)
-    fig.add_trace(go.Bar(x=symbols, y=prices, marker_color='#636EFA'), row=1, col=2)
+    # 3. Live Price Changes (Last 5 changes)
+    if selected_symbol and selected_symbol in market_data_dict:
+        selected_data = market_data_dict[selected_symbol]
+        if len(selected_data['prices']) >= 6:
+            recent_prices = selected_data['prices'][-6:]
+            price_changes = [((recent_prices[i] - recent_prices[i-1]) / recent_prices[i-1] * 100) 
+                           for i in range(1, len(recent_prices))]
+            
+            fig.add_trace(
+                go.Scatter(
+                    x=selected_data['timestamps'][-5:],
+                    y=price_changes,
+                    mode='lines+markers+text',
+                    name=f'{selected_symbol} Changes',
+                    line=dict(color='#FECA57', width=4),
+                    marker=dict(size=8),
+                    text=[f"{x:+.2f}%" for x in price_changes],
+                    textposition='top center'
+                ),
+                row=2, col=1
+            )
+    
+    # 4. Market Sentiment Pie Chart
+    sentiment_data = {
+        'Bullish': len([d for d in market_data_dict.values() if d['change'] > 0]),
+        'Bearish': len([d for d in market_data_dict.values() if d['change'] < 0]),
+        'Neutral': len([d for d in market_data_dict.values() if d['change'] == 0])
+    }
+    
+    fig.add_trace(
+        go.Pie(
+            labels=list(sentiment_data.keys()),
+            values=list(sentiment_data.values()),
+            hole=0.4,
+            marker_colors=['#00CC96', '#EF553B', '#636EFA'],
+            name='Market Sentiment'
+        ),
+        row=2, col=2
+    )
     
+    # Update layout for professional appearance
     fig.update_layout(
-        title='Stock Performance Overview',
+        height=800,
+        title_text="🤖 LIVE AI TRADING DASHBOARD - Real-Time Market Data",
+        title_font_size=20,
+        showlegend=True,
         template='plotly_dark',
-        height=400,
-        showlegend=False
+        font=dict(family="Arial", size=12, color="white"),
+        margin=dict(t=100, b=50, l=50, r=50)
     )
     
-    return fig
-
-def analyze_single_stock(symbol):
-    """Analyze a single stock"""
-    price_data = market_data.get_stock_data(symbol)
-    analyses = trading_agents.analyze_stock(symbol, price_data)
-    
-    chart = create_stock_chart(symbol, price_data)
-    
-    analysis_output = f"# {symbol} Analysis Report\n\n"
-    analysis_output += f"**Current Price:** ${price_data['current_price']:.2f}\n"
-    analysis_output += f"**30-Day Change:** {price_data['change']:+.2f}%\n\n"
+    # Update axes labels
+    fig.update_xaxes(title_text="Time (Last 30 Minutes)", row=1, col=1)
+    fig.update_xaxes(title_text="Stocks", row=1, col=2)
+    fig.update_xaxes(title_text="Time", row=2, col=1)
     
-    for agent_type, analysis in analyses.items():
-        analysis_output += f"## {analysis['emoji']} {analysis['name']}\n"
-        analysis_output += f"{analysis['analysis']}\n\n"
+    fig.update_yaxes(title_text="Price ($)", row=1, col=1)
+    fig.update_yaxes(title_text="Change (%)", row=1, col=2)
+    fig.update_yaxes(title_text="Price Change (%)", row=2, col=1)
     
-    return chart, analysis_output
+    return fig
 
-def analyze_all_stocks():
-    """Analyze all tracked stocks"""
-    stocks_data = {}
-    for symbol in market_data.symbols:
-        stocks_data[symbol] = market_data.get_stock_data(symbol)
+def generate_agent_analysis(symbol, market_data_dict):
+    """Generate multi-agent analysis for a specific symbol"""
+    if not symbol:
+        # Analyze all symbols if none specified
+        all_analysis = "# 📊 Multi-Stock Analysis Report\n\n"
+        
+        for sym in market_data_dict.keys():
+            analysis = trading_agents.analyze_market(sym, market_data_dict)
+            decision = analysis['decision']
+            
+            all_analysis += f"## {sym}\n"
+            all_analysis += f"**Price:** ${market_data_dict[sym]['current_price']:.2f} | "
+            all_analysis += f"**Change:** {market_data_dict[sym]['change']:+.2f}%\n"
+            all_analysis += f"**Decision:** {decision['decision']} ({decision['confidence']}% confidence)\n\n"
+            
+            if sym == list(market_data_dict.keys())[0]:  # Show full analysis for first symbol
+                all_analysis += "### Detailed Analysis:\n"
+                for agent_type, agent_analysis in analysis.items():
+                    if agent_type != 'decision':
+                        all_analysis += f"**{agent_analysis['emoji']} {agent_analysis['title']}**\n"
+                        all_analysis += f"{agent_analysis['analysis']}\n\n"
+        
+        return all_analysis
     
-    dashboard = create_performance_dashboard(stocks_data)
+    else:
+        # Analyze specific symbol
+        analysis = trading_agents.analyze_market(symbol.upper(), market_data_dict)
+        
+        analysis_text = f"# 🎯 {symbol.upper()} - AI Trading Analysis\n\n"
+        analysis_text += f"**Current Price:** ${market_data_dict.get(symbol.upper(), {}).get('current_price', 'N/A'):.2f}\n"
+        analysis_text += f"**24h Change:** {market_data_dict.get(symbol.upper(), {}).get('change', 'N/A'):+.2f}%\n"
+        analysis_text += f"**Last Updated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+        
+        for agent_type, agent_analysis in analysis.items():
+            analysis_text += f"## {agent_analysis['emoji']} {agent_analysis['title']}\n"
+            analysis_text += f"{agent_analysis['analysis']}\n\n"
+        
+        return analysis_text
+
+def update_interface(symbol_input):
+    """Main function to update the entire interface"""
+    # Get fresh market data
+    current_market_data = market_data.get_live_data()
     
-    analysis_output = "# Multi-Agent Trading Analysis\n\n"
+    # Create visualizations
+    dashboard = create_real_time_dashboard(current_market_data, symbol_input)
     
-    for symbol in market_data.symbols:
-        analyses = trading_agents.analyze_stock(symbol, stocks_data[symbol])
-        decision_line = analyses['decision']['analysis'].split('\n')[0]
-        
-        analysis_output += f"## {symbol}\n"
-        analysis_output += f"**Price:** ${stocks_data[symbol]['current_price']:.2f} | "
-        analysis_output += f"**Change:** {stocks_data[symbol]['change']:+.2f}%\n"
-        analysis_output += f"**Decision:** {decision_line}\n\n"
+    # Generate analysis
+    analysis = generate_agent_analysis(symbol_input, current_market_data)
     
-    return dashboard, analysis_output
+    return dashboard, analysis
 
-def update_analysis(symbol_input):
-    """Update analysis based on user input"""
-    if symbol_input:
-        symbol = symbol_input.upper().strip()
-        return analyze_single_stock(symbol)
-    else:
-        return analyze_all_stocks()
-
-# Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft(), title="AI Trading Agents") as demo:
+# Create Gradio Interface
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="slate"
+    ),
+    title="🤖 AI Trading Agents - Real-Time System",
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .analysis-box {
+        border-left: 4px solid #4ECDC4;
+        padding-left: 15px;
+        margin: 10px 0;
+    }
+    """
+) as demo:
+    
     gr.Markdown("""
     # 🤖 Multi-Agent AI Trading System
-    **Professional stock analysis powered by AI agents**
+    ## *Real-Time Market Analysis & Trading Decisions*
+    
+    **Professional stock analysis powered by multiple AI agents working in coordination**
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
+            gr.Markdown("### 🎯 Stock Selection")
             symbol_input = gr.Textbox(
-                label="Enter Stock Symbol (e.g., AAPL, TSLA)",
-                placeholder="Leave empty for all tracked stocks...",
+                label="Enter Stock Symbol",
+                placeholder="e.g., AAPL, TSLA, NVDA... (leave empty for all)",
                 max_lines=1
             )
-            analyze_btn = gr.Button("Analyze Stock", variant="primary")
-        
+            analyze_btn = gr.Button(
+                "🔄 Analyze Now", 
+                variant="primary",
+                size="lg"
+            )
+            gr.Markdown("""
+            **Tracked Stocks:** AAPL, GOOGL, MSFT, TSLA
+            
+            *Data updates every 30 seconds automatically*
+            """)
+            
         with gr.Column(scale=2):
-            gr.Markdown("### Live Market Analysis")
+            gr.Markdown("### 📊 Live Market Dashboard")
     
     with gr.Tabs():
-        with gr.TabItem("📈 Charts"):
+        with gr.TabItem("📈 Live Charts"):
+            with gr.Row():
+                chart_output = gr.Plot(
+                    label="Real-Time Market Dashboard",
+                    show_label=True
+                )
+        
+        with gr.TabItem("🤖 AI Analysis"):
             with gr.Row():
-                chart_output = gr.Plot(label="Price Chart")
-                dashboard_output = gr.Plot(label="Performance Dashboard")
+                analysis_output = gr.Markdown(
+                    label="Multi-Agent Analysis Report",
+                    show_label=True
+                )
+    
+    with gr.Row():
+        gr.Markdown("""
+        ---
+        **🔍 System Features:**
+        - 📊 **Research Agent**: Fundamental analysis & market sentiment
+        - 📈 **Technical Agent**: Price patterns & trading signals
+        - 🛡️ **Risk Agent**: Position sizing & risk management  
+        - 🎯 **Decision Engine**: Final trading recommendations
         
-        with gr.TabItem("📊 Analysis"):
-            analysis_output = gr.Markdown(label="AI Analysis Report")
+        *Last System Update: {time}*
+        """.format(time=datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
     
     # Event handlers
     analyze_btn.click(
-        fn=update_analysis,
+        fn=update_interface,
         inputs=[symbol_input],
         outputs=[chart_output, analysis_output]
     )
     
-    # Load initial analysis
+    # Auto-refresh every 30 seconds
     demo.load(
-        fn=analyze_all_stocks,
-        outputs=[dashboard_output, analysis_output]
+        fn=update_interface,
+        inputs=[symbol_input],
+        outputs=[chart_output, analysis_output],
+        every=30  # Refresh every 30 seconds
     )
 
-# For Hugging Face Spaces
+# Launch for Hugging Face Spaces
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=True
+        share=True,
+        show_error=True
     )