Restore original app.py (1050 lines) + share=True

app.py

@@ -1 +1,1050 @@
-Downloaded file
+"""AlphaForge x K2 Think V2 — Elite Quant Trading Demo
+
+Built for the Build with K2 Think V2 Challenge (MBZUAI)
+
+Features:
+- K2 Think V2 API integration for AI-powered financial reasoning
+- Real-time stock data via yfinance
+- Technical analysis (RSI, MACD, Bollinger, VWAP)
+- Portfolio optimization & risk metrics
+- Alpha signal generation
+- AI-powered market analysis with chain-of-thought reasoning
+
+API Key: IFM-4SpQ0qEg0Wlsw04O
+"""
+import os
+import json
+import time
+import gradio as gr
+import requests
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import warnings
+warnings.filterwarnings('ignore')
+
+
+# ──────────────────────────────────────────────────────────────
+# K2 Think V2 API Configuration
+# ──────────────────────────────────────────────────────────────
+K2_API_KEY = os.environ.get("K2_API_KEY", "IFM-4SpQ0qEg0Wlsw04O")
+K2_BASE_URL = "https://api.k2think.ai/v1/chat/completions"
+K2_MODEL = "MBZUAI-IFM/K2-Think-v2"
+
+
+# ──────────────────────────────────────────────────────────────
+# K2 Think V2 API Client
+# ──────────────────────────────────────────────────────────────
+class K2ThinkClient:
+    """Client for K2 Think V2 API — state-of-the-art reasoning model"""
+    
+    def __init__(self, api_key: str = K2_API_KEY, base_url: str = K2_BASE_URL):
+        self.api_key = api_key
+        self.base_url = base_url
+        self.headers = {
+            "accept": "application/json",
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+    
+    def chat(self, messages: list, temperature: float = 0.7, 
+             max_tokens: int = 4096, stream: bool = False) -> str:
+        """Send chat completion request to K2 Think V2"""
+        payload = {
+            "model": K2_MODEL,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": stream
+        }
+        
+        try:
+            response = requests.post(
+                self.base_url,
+                headers=self.headers,
+                json=payload,
+                timeout=120
+            )
+            response.raise_for_status()
+            result = response.json()
+            
+            if 'choices' in result and len(result['choices']) > 0:
+                return result['choices'][0]['message']['content']
+            return f"Error: Unexpected response format: {result}"
+            
+        except requests.exceptions.Timeout:
+            return "Error: Request timed out. K2 Think V2 API may be experiencing high load."
+        except requests.exceptions.RequestException as e:
+            return f"Error: API request failed - {str(e)}"
+    
+    def analyze_market(self, ticker: str, data_summary: str, 
+                       technical_summary: str) -> str:
+        """Use K2 Think V2 to analyze market conditions"""
+        prompt = f"""You are an elite quantitative analyst at a top hedge fund (Jane Street / Two Sigma level). 
+Analyze the following financial data with deep reasoning and chain-of-thought analysis.
+
+TICKER: {ticker}
+
+MARKET DATA SUMMARY:
+{data_summary}
+
+TECHNICAL INDICATORS:
+{technical_summary}
+
+Please provide:
+1. **Executive Summary** — Key findings in 3 bullet points
+2. **Technical Analysis** — Interpret RSI, MACD, Bollinger Bands signals
+3. **Risk Assessment** — Volatility regime, tail risks, VaR estimation
+4. **Alpha Signal** — Directional bias (Bullish/Neutral/Bearish) with confidence %
+5. **Actionable Recommendation** — Specific trade idea with entry, stop-loss, target
+6. **Catalyst Watch** — What news/events could move this ticker next week
+
+Think step-by-step and show your reasoning clearly."""
+
+        messages = [{"role": "user", "content": prompt}]
+        return self.chat(messages, temperature=0.3, max_tokens=4096)
+    
+    def portfolio_advice(self, portfolio_data: str, risk_metrics: str) -> str:
+        """AI-powered portfolio optimization advice"""
+        prompt = f"""You are a portfolio manager at a quant hedge fund managing $500M AUM.
+Provide institutional-grade portfolio analysis.
+
+PORTFOLIO HOLDINGS:
+{portfolio_data}
+
+RISK METRICS:
+{risk_metrics}
+
+Please provide:
+1. **Portfolio Health Score** (0-100) and grade
+2. **Concentration Risk** — Are we over-exposed to any sector/style?
+3. **Correlation Analysis** — Hidden risks from correlated positions
+4. **Rebalancing Recommendation** — Specific weight adjustments with %
+5. **Hedging Strategy** — Options/ETFs to reduce tail risk
+6. **Expected Return & Sharpe** — Forward-looking estimate
+
+Use quantitative reasoning. Reference specific numbers from the data."""
+
+        messages = [{"role": "user", "content": prompt}]
+        return self.chat(messages, temperature=0.3, max_tokens=4096)
+    
+    def explain_strategy(self, strategy_name: str, metrics: str) -> str:
+        """Explain trading strategy performance with AI reasoning"""
+        prompt = f"""Explain this trading strategy's performance like you're teaching a quant interview candidate.
+
+STRATEGY: {strategy_name}
+
+PERFORMANCE METRICS:
+{metrics}
+
+Provide:
+1. **Strategy Intuition** — What economic/behavioral mechanism does it exploit?
+2. **Performance Attribution** — Break down P&L sources (alpha, beta, luck)
+3. **Risk-Adjusted Quality** — Sharpe, Sortino, max drawdown analysis
+4. **Benchmark Comparison** — How does it compare to buy-and-hold?
+5. **Edge Sustainability** — Will this alpha persist or decay?
+6. **Improvement Ideas** — 3 specific enhancements with expected impact
+
+Be insightful and educational."""
+
+        messages = [{"role": "user", "content": prompt}]
+        return self.chat(messages, temperature=0.5, max_tokens=4096)
+
+
+# ──────────────────────────────────────────────────────────────
+# Market Data & Technical Analysis
+# ──────────────────────────────────────────────────────────────
+def fetch_stock_data(ticker: str, period: str = "6mo", interval: str = "1d"):
+    """Fetch stock data with error handling"""
+    try:
+        stock = yf.Ticker(ticker.upper().strip())
+        df = stock.history(period=period, interval=interval)
+        
+        if df.empty:
+            return None, f"No data found for {ticker}. Please check the ticker symbol."
+        
+        info = stock.info
+        return df, info
+    except Exception as e:
+        return None, f"Error fetching data: {str(e)}"
+
+
+def compute_technical_indicators(df: pd.DataFrame) -> pd.DataFrame:
+    """Compute technical indicators"""
+    df = df.copy()
+    
+    # Returns
+    df['Returns'] = df['Close'].pct_change()
+    
+    # Simple Moving Averages
+    df['SMA_20'] = df['Close'].rolling(20).mean()
+    df['SMA_50'] = df['Close'].rolling(50).mean()
+    df['SMA_200'] = df['Close'].rolling(200).mean()
+    
+    # EMA
+    df['EMA_12'] = df['Close'].ewm(span=12, adjust=False).mean()
+    df['EMA_26'] = df['Close'].ewm(span=26, adjust=False).mean()
+    
+    # MACD
+    df['MACD'] = df['EMA_12'] - df['EMA_26']
+    df['MACD_Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
+    df['MACD_Histogram'] = df['MACD'] - df['MACD_Signal']
+    
+    # RSI
+    delta = df['Close'].diff()
+    gain = (delta.where(delta > 0, 0)).rolling(14).mean()
+    loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
+    rs = gain / (loss + 1e-10)
+    df['RSI'] = 100 - (100 / (1 + rs))
+    
+    # Bollinger Bands
+    df['BB_Middle'] = df['Close'].rolling(20).mean()
+    bb_std = df['Close'].rolling(20).std()
+    df['BB_Upper'] = df['BB_Middle'] + 2 * bb_std
+    df['BB_Lower'] = df['BB_Middle'] - 2 * bb_std
+    df['BB_Width'] = (df['BB_Upper'] - df['BB_Lower']) / df['BB_Middle']
+    df['BB_Position'] = (df['Close'] - df['BB_Lower']) / (df['BB_Upper'] - df['BB_Lower'] + 1e-10)
+    
+    # VWAP
+    typical_price = (df['High'] + df['Low'] + df['Close']) / 3
+    df['VWAP'] = (typical_price * df['Volume']).cumsum() / (df['Volume'].cumsum() + 1e-10)
+    
+    # ATR (Average True Range)
+    high_low = df['High'] - df['Low']
+    high_close = np.abs(df['High'] - df['Close'].shift())
+    low_close = np.abs(df['Low'] - df['Close'].shift())
+    tr = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
+    df['ATR'] = tr.rolling(14).mean()
+    
+    # Stochastic Oscillator
+    low_14 = df['Low'].rolling(14).min()
+    high_14 = df['High'].rolling(14).max()
+    df['Stoch_K'] = 100 * (df['Close'] - low_14) / (high_14 - low_14 + 1e-10)
+    df['Stoch_D'] = df['Stoch_K'].rolling(3).mean()
+    
+    # Volume indicators
+    df['Volume_MA'] = df['Volume'].rolling(20).mean()
+    df['Volume_Ratio'] = df['Volume'] / (df['Volume_MA'] + 1e-10)
+    
+    return df
+
+
+def generate_signals(df: pd.DataFrame) -> dict:
+    """Generate alpha signals from technical indicators"""
+    latest = df.iloc[-1]
+    prev = df.iloc[-2] if len(df) > 1 else latest
+    
+    signals = {
+        'trend': 'neutral',
+        'momentum': 'neutral',
+        'volatility': 'normal',
+        'volume': 'normal',
+        'composite_score': 50,
+        'confidence': 50
+    }
+    
+    # Trend signal
+    if latest['Close'] > latest['SMA_20'] > latest['SMA_50']:
+        signals['trend'] = 'bullish'
+    elif latest['Close'] < latest['SMA_20'] < latest['SMA_50']:
+        signals['trend'] = 'bearish'
+    
+    # Momentum signal
+    if latest['RSI'] < 30:
+        signals['momentum'] = 'oversold (bullish bounce potential)'
+    elif latest['RSI'] > 70:
+        signals['momentum'] = 'overbought (bearish pullback risk)'
+    elif latest['MACD'] > latest['MACD_Signal'] and prev['MACD'] <= prev['MACD_Signal']:
+        signals['momentum'] = 'MACD bullish crossover'
+    elif latest['MACD'] < latest['MACD_Signal'] and prev['MACD'] >= prev['MACD_Signal']:
+        signals['momentum'] = 'MACD bearish crossover'
+    
+    # Volatility signal
+    bb_width = latest['BB_Width']
+    if bb_width > df['BB_Width'].quantile(0.9):
+        signals['volatility'] = 'expanding (breakout likely)'
+    elif bb_width < df['BB_Width'].quantile(0.1):
+        signals['volatility'] = 'contracting (squeeze setup)'
+    
+    # Volume signal
+    if latest['Volume_Ratio'] > 2.0:
+        signals['volume'] = 'heavy (institutional interest)'
+    
+    # Composite score (0-100, >60 bullish, <40 bearish)
+    score = 50
+    if signals['trend'] == 'bullish': score += 15
+    if signals['trend'] == 'bearish': score -= 15
+    if 'oversold' in signals['momentum']: score += 10
+    if 'overbought' in signals['momentum']: score -= 10
+    if 'bullish crossover' in signals['momentum']: score += 10
+    if 'bearish crossover' in signals['momentum']: score -= 10
+    if latest['Close'] > latest['VWAP']: score += 5
+    if latest['Close'] < latest['VWAP']: score -= 5
+    
+    signals['composite_score'] = max(0, min(100, score))
+    
+    # Confidence based on indicator agreement
+    bullish_count = sum([
+        signals['trend'] == 'bullish',
+        'oversold' in signals['momentum'] or 'bullish crossover' in signals['momentum'],
+        latest['Close'] > latest['VWAP']
+    ])
+    bearish_count = sum([
+        signals['trend'] == 'bearish',
+        'overbought' in signals['momentum'] or 'bearish crossover' in signals['momentum'],
+        latest['Close'] < latest['VWAP']
+    ])
+    
+    signals['confidence'] = max(bullish_count, bearish_count) * 33 + 1
+    signals['direction'] = 'BULLISH' if score > 60 else 'BEARISH' if score < 40 else 'NEUTRAL'
+    
+    return signals
+
+
+def compute_risk_metrics(df: pd.DataFrame) -> dict:
+    """Compute portfolio risk metrics"""
+    returns = df['Returns'].dropna()
+    
+    if len(returns) < 30:
+        return {}
+    
+    # Basic stats
+    annual_return = returns.mean() * 252
+    annual_vol = returns.std() * np.sqrt(252)
+    sharpe = annual_return / (annual_vol + 1e-10)
+    
+    # Sortino (downside deviation)
+    downside = returns[returns < 0]
+    downside_dev = downside.std() * np.sqrt(252) if len(downside) > 0 else 1e-10
+    sortino = annual_return / (downside_dev + 1e-10)
+    
+    # Max drawdown
+    cumulative = (1 + returns).cumprod()
+    running_max = cumulative.expanding().max()
+    drawdown = (cumulative - running_max) / running_max
+    max_dd = drawdown.min()
+    
+    # VaR / CVaR
+    var_95 = np.percentile(returns, 5)
+    var_99 = np.percentile(returns, 1)
+    cvar_95 = returns[returns <= var_95].mean() if len(returns[returns <= var_95]) > 0 else var_95
+    
+    # Calmar
+    calmar = annual_return / (abs(max_dd) + 1e-10)
+    
+    # Skewness and kurtosis
+    skew = returns.skew()
+    kurt = returns.kurtosis()
+    
+    return {
+        'annual_return': annual_return,
+        'annual_volatility': annual_vol,
+        'sharpe_ratio': sharpe,
+        'sortino_ratio': sortino,
+        'max_drawdown': max_dd,
+        'var_95_daily': var_95,
+        'var_99_daily': var_99,
+        'cvar_95_daily': cvar_95,
+        'calmar_ratio': calmar,
+        'skewness': skew,
+        'excess_kurtosis': kurt,
+        'win_rate': (returns > 0).mean(),
+        'avg_win': returns[returns > 0].mean() if len(returns[returns > 0]) > 0 else 0,
+        'avg_loss': returns[returns < 0].mean() if len(returns[returns < 0]) > 0 else 0,
+        'profit_factor': abs(returns[returns > 0].sum() / (returns[returns < 0].sum() + 1e-10))
+    }
+
+
+# ──────────────────────────────────────────────────────────────
+# Plotly Charts
+# ──────────────────────────────────────────────────────────────
+def create_candlestick_chart(df: pd.DataFrame, ticker: str):
+    """Create interactive candlestick chart with indicators"""
+    fig = make_subplots(
+        rows=3, cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.05,
+        row_heights=[0.6, 0.2, 0.2],
+        subplot_titles=(f'{ticker} Price', 'Volume', 'RSI')
+    )
+    
+    # Candlestick
+    fig.add_trace(go.Candlestick(
+        x=df.index,
+        open=df['Open'],
+        high=df['High'],
+        low=df['Low'],
+        close=df['Close'],
+        name='Price'
+    ), row=1, col=1)
+    
+    # SMAs
+    fig.add_trace(go.Scatter(x=df.index, y=df['SMA_20'], 
+                              line=dict(color='orange', width=1), name='SMA 20'), row=1, col=1)
+    fig.add_trace(go.Scatter(x=df.index, y=df['SMA_50'], 
+                              line=dict(color='blue', width=1), name='SMA 50'), row=1, col=1)
+    
+    # Bollinger Bands
+    fig.add_trace(go.Scatter(x=df.index, y=df['BB_Upper'], 
+                              line=dict(color='gray', width=1, dash='dash'), 
+                              name='BB Upper', opacity=0.5), row=1, col=1)
+    fig.add_trace(go.Scatter(x=df.index, y=df['BB_Lower'], 
+                              line=dict(color='gray', width=1, dash='dash'), 
+                              name='BB Lower', opacity=0.5), row=1, col=1)
+    
+    # Volume
+    colors = ['green' if df['Close'].iloc[i] >= df['Open'].iloc[i] else 'red' 
+              for i in range(len(df))]
+    fig.add_trace(go.Bar(x=df.index, y=df['Volume'], 
+                         marker_color=colors, name='Volume', opacity=0.7), row=2, col=1)
+    
+    # RSI
+    fig.add_trace(go.Scatter(x=df.index, y=df['RSI'], 
+                              line=dict(color='purple', width=1.5), name='RSI'), row=3, col=1)
+    fig.add_hline(y=70, line_dash="dash", line_color="red", row=3, col=1)
+    fig.add_hline(y=30, line_dash="dash", line_color="green", row=3, col=1)
+    fig.add_hline(y=50, line_dash="dot", line_color="gray", row=3, col=1)
+    
+    fig.update_layout(
+        title=f'{ticker} Technical Analysis Dashboard',
+        xaxis_rangeslider_visible=False,
+        height=800,
+        template='plotly_white',
+        showlegend=True,
+        legend=dict(orientation='h', yanchor='bottom', y=1.02, xanchor='right', x=1)
+    )
+    
+    fig.update_yaxes(title_text="Price ($)", row=1, col=1)
+    fig.update_yaxes(title_text="Volume", row=2, col=1)
+    fig.update_yaxes(title_text="RSI", range=[0, 100], row=3, col=1)
+    
+    return fig
+
+
+def create_macd_chart(df: pd.DataFrame, ticker: str):
+    """Create MACD chart"""
+    fig = make_subplots(rows=1, cols=1)
+    
+    fig.add_trace(go.Scatter(x=df.index, y=df['MACD'], 
+                              line=dict(color='blue', width=1.5), name='MACD'), row=1, col=1)
+    fig.add_trace(go.Scatter(x=df.index, y=df['MACD_Signal'], 
+                              line=dict(color='orange', width=1.5), name='Signal'), row=1, col=1)
+    
+    colors = ['green' if val >= 0 else 'red' for val in df['MACD_Histogram']]
+    fig.add_trace(go.Bar(x=df.index, y=df['MACD_Histogram'], 
+                         marker_color=colors, name='Histogram', opacity=0.6), row=1, col=1)
+    
+    fig.update_layout(
+        title=f'{ticker} MACD',
+        height=400,
+        template='plotly_white',
+        xaxis_rangeslider_visible=False
+    )
+    
+    return fig
+
+
+def create_return_distribution(returns: pd.Series, ticker: str):
+    """Create return distribution histogram"""
+    fig = go.Figure()
+    
+    fig.add_trace(go.Histogram(
+        x=returns,
+        nbinsx=50,
+        name='Returns',
+        marker_color='steelblue',
+        opacity=0.7
+    ))
+    
+    # Add normal overlay
+    x_range = np.linspace(returns.min(), returns.max(), 100)
+    mu, sigma = returns.mean(), returns.std()
+    normal_pdf = len(returns) * (x_range[1] - x_range[0]) * stats.norm.pdf(x_range, mu, sigma)
+    fig.add_trace(go.Scatter(x=x_range, y=normal_pdf, 
+                              mode='lines', line=dict(color='red', dash='dash'),
+                              name='Normal'))
+    
+    fig.update_layout(
+        title=f'{ticker} Return Distribution (vs Normal)',
+        xaxis_title='Daily Return',
+        yaxis_title='Frequency',
+        height=400,
+        template='plotly_white',
+        bargap=0.1
+    )
+    
+    return fig
+
+
+# ──────────────────────────────────────────────────────────────
+# Portfolio Optimization
+# ──────────────────────────────────────────────────────────────
+def optimize_portfolio(tickers: list, period: str = "1y"):
+    """Mean-variance optimization for a portfolio"""
+    try:
+        # Fetch data
+        data = {}
+        for t in tickers:
+            t = t.strip().upper()
+            if not t:
+                continue
+            df, _ = fetch_stock_data(t, period=period)
+            if df is not None and len(df) > 30:
+                data[t] = df['Close']
+        
+        if len(data) < 2:
+            return None, "Need at least 2 valid tickers for portfolio optimization."
+        
+        # Align and compute returns
+        prices = pd.DataFrame(data)
+        prices = prices.dropna()
+        returns = prices.pct_change().dropna()
+        
+        if len(returns) < 30:
+            return None, "Insufficient data after alignment."
+        
+        # Expected returns and covariance
+        mu = returns.mean() * 252
+        sigma = returns.cov() * 252
+        
+        # Optimize: max Sharpe
+        n = len(mu)
+        
+        def neg_sharpe(weights):
+            weights = np.array(weights)
+            port_return = np.dot(weights, mu)
+            port_vol = np.sqrt(np.dot(weights.T, np.dot(sigma, weights)))
+            return -(port_return / (port_vol + 1e-10))
+        
+        constraints = {'type': 'eq', 'fun': lambda w: np.sum(w) - 1}
+        bounds = tuple((0, 0.5) for _ in range(n))  # Max 50% per asset
+        x0 = np.ones(n) / n
+        
+        result = minimize(neg_sharpe, x0, method='SLSQP', bounds=bounds, constraints=constraints)
+        
+        optimal_weights = result.x
+        
+        # Portfolio metrics
+        port_return = np.dot(optimal_weights, mu)
+        port_vol = np.sqrt(np.dot(optimal_weights.T, np.dot(sigma, optimal_weights)))
+        port_sharpe = port_return / (port_vol + 1e-10)
+        
+        # Equal weight for comparison
+        eq_weights = np.ones(n) / n
+        eq_return = np.dot(eq_weights, mu)
+        eq_vol = np.sqrt(np.dot(eq_weights.T, np.dot(sigma, eq_weights)))
+        eq_sharpe = eq_return / (eq_vol + 1e-10)
+        
+        return {
+            'tickers': list(data.keys()),
+            'optimal_weights': optimal_weights,
+            'equal_weights': eq_weights,
+            'optimal_return': port_return,
+            'optimal_volatility': port_vol,
+            'optimal_sharpe': port_sharpe,
+            'equal_return': eq_return,
+            'equal_volatility': eq_vol,
+            'equal_sharpe': eq_sharpe,
+            'annual_returns': mu,
+            'covariance': sigma
+        }, None
+        
+    except Exception as e:
+        return None, f"Optimization error: {str(e)}"
+
+
+def create_efficient_frontier(opt_result: dict):
+    """Plot efficient frontier"""
+    mu = opt_result['annual_returns']
+    sigma = opt_result['covariance']
+    n = len(mu)
+    
+    # Generate random portfolios
+    n_portfolios = 5000
+    weights = np.random.dirichlet(np.ones(n), n_portfolios)
+    
+    port_returns = np.dot(weights, mu)
+    port_vols = np.array([np.sqrt(np.dot(w.T, np.dot(sigma, w))) for w in weights])
+    port_sharpes = port_returns / (port_vols + 1e-10)
+    
+    fig = go.Figure()
+    
+    # Scatter of random portfolios
+    fig.add_trace(go.Scatter(
+        x=port_vols, y=port_returns,
+        mode='markers',
+        marker=dict(
+            size=4,
+            color=port_sharpes,
+            colorscale='Viridis',
+            showscale=True,
+            colorbar=dict(title='Sharpe')
+        ),
+        name='Random Portfolios'
+    ))
+    
+    # Optimal portfolio
+    fig.add_trace(go.Scatter(
+        x=[opt_result['optimal_volatility']],
+        y=[opt_result['optimal_return']],
+        mode='markers+text',
+        marker=dict(size=15, color='red', symbol='star'),
+        text=['Optimal'],
+        textposition='top center',
+        name='Optimal Portfolio'
+    ))
+    
+    # Equal weight
+    fig.add_trace(go.Scatter(
+        x=[opt_result['equal_volatility']],
+        y=[opt_result['equal_return']],
+        mode='markers+text',
+        marker=dict(size=12, color='orange', symbol='diamond'),
+        text=['Equal Weight'],
+        textposition='bottom center',
+        name='Equal Weight'
+    ))
+    
+    fig.update_layout(
+        title='Efficient Frontier (Monte Carlo Simulation)',
+        xaxis_title='Annual Volatility',
+        yaxis_title='Annual Return',
+        template='plotly_white',
+        height=500
+    )
+    
+    return fig
+
+
+# ──────────────────────────────────────────────────────────────
+# Gradio UI Functions
+# ──────────────────────────────────────────────────────────────
+def analyze_ticker(ticker: str, period: str = "6mo"):
+    """Main analysis function for single ticker"""
+    ticker = ticker.strip().upper()
+    if not ticker:
+        return None, None, None, None, "Please enter a ticker symbol."
+    
+    df, info = fetch_stock_data(ticker, period=period)
+    
+    if df is None:
+        return None, None, None, None, info
+    
+    # Compute indicators
+    df = compute_technical_indicators(df)
+    signals = generate_signals(df)
+    risk = compute_risk_metrics(df)
+    
+    # Create charts
+    candlestick = create_candlestick_chart(df, ticker)
+    macd_chart = create_macd_chart(df, ticker)
+    returns_chart = create_return_distribution(df['Returns'].dropna(), ticker)
+    
+    # Summary text
+    latest = df.iloc[-1]
+    prev = df.iloc[-2] if len(df) > 1 else latest
+    
+    summary = f"""## {ticker} Analysis
+
+**Current Price:** ${latest['Close']:.2f} | **Change:** {((latest['Close']/prev['Close']-1)*100):+.2f}%
+
+### Technical Signals
+| Indicator | Value | Signal |
+|-----------|-------|--------|
+| RSI (14) | {latest['RSI']:.1f} | {'Oversold' if latest['RSI']<30 else 'Overbought' if latest['RSI']>70 else 'Neutral'} |
+| MACD | {latest['MACD']:.3f} | {'Bullish' if latest['MACD']>latest['MACD_Signal'] else 'Bearish'} |
+| Bollinger Position | {latest['BB_Position']:.1%} | {'Near upper band' if latest['BB_Position']>0.8 else 'Near lower band' if latest['BB_Position']<0.2 else 'Middle'} |
+| VWAP Position | {'Above VWAP' if latest['Close']>latest['VWAP'] else 'Below VWAP'} | {'Bullish' if latest['Close']>latest['VWAP'] else 'Bearish'} |
+| Volume vs Avg | {latest['Volume_Ratio']:.1f}x | {'Heavy' if latest['Volume_Ratio']>1.5 else 'Normal'} |
+
+### Composite Signal
+**Direction:** {signals['direction']} | **Score:** {signals['composite_score']}/100 | **Confidence:** {signals['confidence']}%
+
+### Risk Metrics
+| Metric | Value |
+|--------|-------|
+| Annualized Return | {risk.get('annual_return', 0)*100:.1f}% |
+| Annualized Volatility | {risk.get('annual_volatility', 0)*100:.1f}% |
+| Sharpe Ratio | {risk.get('sharpe_ratio', 0):.2f} |
+| Sortino Ratio | {risk.get('sortino_ratio', 0):.2f} |
+| Max Drawdown | {risk.get('max_drawdown', 0)*100:.1f}% |
+| VaR (95%) | {risk.get('var_95_daily', 0)*100:.2f}% |
+| CVaR (95%) | {risk.get('cvar_95_daily', 0)*100:.2f}% |
+| Calmar Ratio | {risk.get('calmar_ratio', 0):.2f} |
+| Win Rate | {risk.get('win_rate', 0)*100:.1f}% |
+| Profit Factor | {risk.get('profit_factor', 0):.2f} |
+| Skewness | {risk.get('skewness', 0):.2f} |
+| Excess Kurtosis | {risk.get('excess_kurtosis', 0):.2f} |
+"""
+    
+    return candlestick, macd_chart, returns_chart, summary, ""
+
+
+def ai_analyze(ticker: str, period: str = "6mo"):
+    """AI-powered analysis using K2 Think V2"""
+    ticker = ticker.strip().upper()
+    if not ticker:
+        return "Please enter a ticker symbol."
+    
+    df, info = fetch_stock_data(ticker, period=period)
+    if df is None:
+        return info
+    
+    df = compute_technical_indicators(df)
+    signals = generate_signals(df)
+    risk = compute_risk_metrics(df)
+    latest = df.iloc[-1]
+    
+    # Build data summary
+    data_summary = f"""
+Ticker: {ticker}
+Current Price: ${latest['Close']:.2f}
+Period: {period}
+Data Points: {len(df)}
+
+Price Action:
+- 20-day SMA: ${latest['SMA_20']:.2f}
+- 50-day SMA: ${latest['SMA_50']:.2f}
+- 52-week High: ${df['High'].max():.2f}
+- 52-week Low: ${df['Low'].min():.2f}
+- ATR (14): ${latest['ATR']:.2f}
+"""
+    
+    technical_summary = f"""
+RSI (14): {latest['RSI']:.1f} ({'oversold' if latest['RSI']<30 else 'overbought' if latest['RSI']>70 else 'neutral'})
+MACD: {latest['MACD']:.3f} vs Signal: {latest['MACD_Signal']:.3f}
+MACD Histogram: {latest['MACD_Histogram']:.3f}
+Bollinger Band Position: {latest['BB_Position']:.1%}
+Stochastic %K: {latest['Stoch_K']:.1f}
+VWAP: ${latest['VWAP']:.2f}
+
+Composite Signal Score: {signals['composite_score']}/100
+Direction: {signals['direction']}
+Confidence: {signals['confidence']}%
+
+Risk Metrics:
+Sharpe: {risk.get('sharpe_ratio', 0):.2f}
+Volatility (ann): {risk.get('annual_volatility', 0)*100:.1f}%
+Max Drawdown: {risk.get('max_drawdown', 0)*100:.1f}%
+VaR 95%: {risk.get('var_95_daily', 0)*100:.2f}%
+"""
+    
+    # Call K2 Think V2
+    client = K2ThinkClient()
+    analysis = client.analyze_market(ticker, data_summary, technical_summary)
+    
+    return analysis
+
+
+def analyze_portfolio(tickers_str: str, period: str = "1y"):
+    """Portfolio optimization and analysis"""
+    tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()]
+    
+    if len(tickers) < 2:
+        return None, None, "Please enter at least 2 tickers separated by commas."
+    
+    # Optimize
+    result, error = optimize_portfolio(tickers, period)
+    
+    if error:
+        return None, None, error
+    
+    # Create efficient frontier
+    frontier = create_efficient_frontier(result)
+    
+    # Weights comparison
+    weights_df = pd.DataFrame({
+        'Ticker': result['tickers'],
+        'Optimal Weight (%)': result['optimal_weights'] * 100,
+        'Equal Weight (%)': result['equal_weights'] * 100
+    })
+    
+    # Summary
+    summary = f"""## Portfolio Optimization Results
+
+**Tickers:** {', '.join(result['tickers'])}
+
+### Optimal Portfolio (Max Sharpe)
+| Metric | Value |
+|--------|-------|
+| Expected Annual Return | {result['optimal_return']*100:.1f}% |
+| Expected Volatility | {result['optimal_volatility']*100:.1f}% |
+| Sharpe Ratio | {result['optimal_sharpe']:.2f} |
+
+### Equal Weight Portfolio (Benchmark)
+| Metric | Value |
+|--------|-------|
+| Expected Annual Return | {result['equal_return']*100:.1f}% |
+| Expected Volatility | {result['equal_volatility']*100:.1f}% |
+| Sharpe Ratio | {result['equal_sharpe']:.2f} |
+
+### Improvement
+| | |
+|-|-|
+| Sharpe Improvement | {((result['optimal_sharpe']/result['equal_sharpe']-1)*100):+.1f}% |
+| Return Improvement | {((result['optimal_return']/result['equal_return']-1)*100):+.1f}% |
+| Risk Reduction | {((1-result['optimal_volatility']/result['equal_volatility'])*100):+.1f}% |
+
+### Optimal Weights
+{weights_df.to_markdown(index=False)}
+"""
+    
+    return frontier, weights_df, summary
+
+
+def ai_portfolio_advice(tickers_str: str, period: str = "1y"):
+    """AI-powered portfolio advice via K2 Think V2"""
+    tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()]
+    
+    if len(tickers) < 2:
+        return "Please enter at least 2 tickers."
+    
+    result, error = optimize_portfolio(tickers, period)
+    if error:
+        return error
+    
+    # Build portfolio data
+    portfolio_data = f"""
+Holdings:
+{chr(10).join([f"- {t}: {w*100:.1f}%" for t, w in zip(result['tickers'], result['optimal_weights'])])}
+
+Expected Return: {result['optimal_return']*100:.1f}%
+Expected Volatility: {result['optimal_volatility']*100:.1f}%
+Sharpe Ratio: {result['optimal_sharpe']:.2f}
+
+Individual Asset Returns (annual):
+{chr(10).join([f"- {t}: {r*100:.1f}%" for t, r in zip(result['tickers'], result['annual_returns'])])}
+"""
+    
+    # Correlation matrix
+    corr = result['covariance']
+    for i in range(len(corr)):
+        corr.iloc[i, i] = np.nan  # Hide diagonal
+    
+    risk_metrics = f"""
+Correlation Matrix (off-diagonal):
+{corr.to_string()}
+
+Highest pairwise correlation: {corr.stack().max():.2f}
+Lowest pairwise correlation: {corr.stack().min():.2f}
+Average correlation: {corr.stack().mean():.2f}
+"""
+    
+    client = K2ThinkClient()
+    advice = client.portfolio_advice(portfolio_data, risk_metrics)
+    
+    return advice
+
+
+# ──────────────────────────────────────────────────────────────
+# Gradio App Builder
+# ──────────────────────────────────────────────────────────────
+def build_app():
+    """Build the Gradio demo app"""
+    
+    with gr.Blocks(
+        title="AlphaForge x K2 Think V2 — Elite Quant Trading",
+        theme=gr.themes.Soft(),
+        css="""
+        .main-title { text-align: center; font-size: 2.5em; font-weight: bold; color: #1a73e8; margin-bottom: 0.2em; }
+        .subtitle { text-align: center; font-size: 1.1em; color: #5f6368; margin-bottom: 1.5em; }
+        .api-badge { text-align: center; background: linear-gradient(90deg, #667eea, #764ba2); 
+                     color: white; padding: 8px 16px; border-radius: 20px; font-weight: 600; }
+        """
+    ) as demo:
+        
+        # Header
+        gr.HTML("""
+        <div class="main-title">🔥 AlphaForge x K2 Think V2</div>
+        <div class="subtitle">Elite Quantitative Trading Platform powered by MBZUAI's State-of-the-Art Reasoning Model</div>
+        <div style="text-align: center; margin-bottom: 20px;">
+            <span class="api-badge">🤖 K2 Think V2 API Active</span>
+            <span style="margin-left: 10px;" class="api-badge">📊 Real-Time Market Data</span>
+            <span style="margin-left: 10px;" class="api-badge">🎯 AI-Powered Alpha</span>
+        </div>
+        """)
+        
+        # ── TAB 1: Single Stock Analysis ──
+        with gr.Tab("📈 Single Stock Analysis"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    ticker_input = gr.Textbox(
+                        label="Stock Ticker",
+                        placeholder="e.g., AAPL, TSLA, NVDA, SPY",
+                        value="AAPL"
+                    )
+                    period_input = gr.Dropdown(
+                        label="Time Period",
+                        choices=["1mo", "3mo", "6mo", "1y", "2y", "5y"],
+                        value="6mo"
+                    )
+                    analyze_btn = gr.Button("🔍 Analyze Stock", variant="primary")
+                    ai_btn = gr.Button("🤖 AI Deep Analysis (K2 Think V2)", variant="secondary")
+                
+                with gr.Column(scale=2):
+                    summary_output = gr.Markdown(label="Analysis Summary")
+            
+            with gr.Row():
+                candlestick_plot = gr.Plot(label="Price & Technicals")
+                macd_plot = gr.Plot(label="MACD")
+            
+            with gr.Row():
+                returns_plot = gr.Plot(label="Return Distribution")
+                ai_output = gr.Textbox(
+                    label="K2 Think V2 AI Analysis",
+                    lines=20,
+                    max_lines=30,
+                    autoscroll=True
+                )
+            
+            error_output = gr.Textbox(label="Status", visible=False)
+            
+            # Bind buttons
+            analyze_btn.click(
+                fn=analyze_ticker,
+                inputs=[ticker_input, period_input],
+                outputs=[candlestick_plot, macd_plot, returns_plot, summary_output, error_output]
+            )
+            
+            ai_btn.click(
+                fn=ai_analyze,
+                inputs=[ticker_input, period_input],
+                outputs=[ai_output]
+            )
+        
+        # ── TAB 2: Portfolio Optimization ──
+        with gr.Tab("💼 Portfolio Optimizer"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    portfolio_input = gr.Textbox(
+                        label="Portfolio Tickers (comma-separated)",
+                        placeholder="e.g., AAPL, MSFT, GOOGL, AMZN, NVDA",
+                        value="AAPL, MSFT, GOOGL, AMZN, NVDA"
+                    )
+                    portfolio_period = gr.Dropdown(
+                        label="Lookback Period",
+                        choices=["6mo", "1y", "2y", "3y"],
+                        value="1y"
+                    )
+                    optimize_btn = gr.Button("🎯 Optimize Portfolio", variant="primary")
+                    ai_portfolio_btn = gr.Button("🤖 AI Portfolio Advice (K2 Think V2)", variant="secondary")
+                
+                with gr.Column(scale=2):
+                    portfolio_summary = gr.Markdown(label="Optimization Results")
+            
+            with gr.Row():
+                frontier_plot = gr.Plot(label="Efficient Frontier")
+                weights_table = gr.DataFrame(label="Optimal Weights")
+            
+            ai_portfolio_output = gr.Textbox(
+                label="K2 Think V2 Portfolio Advice",
+                lines=20,
+                max_lines=30
+            )
+            
+            optimize_btn.click(
+                fn=analyze_portfolio,
+                inputs=[portfolio_input, portfolio_period],
+                outputs=[frontier_plot, weights_table, portfolio_summary]
+            )
+            
+            ai_portfolio_btn.click(
+                fn=ai_portfolio_advice,
+                inputs=[portfolio_input, portfolio_period],
+                outputs=[ai_portfolio_output]
+            )
+        
+        # ── TAB 3: AI Chat ──
+        with gr.Tab("💬 K2 Think V2 Chat"):
+            gr.Markdown("## Direct Chat with K2 Think V2\nAsk any financial question, strategy idea, or market analysis.")
+            
+            chat_input = gr.Textbox(
+                label="Your Question",
+                placeholder="e.g., 'Analyze the bull case for AI stocks in 2025' or 'Explain pairs trading with a real example'",
+                lines=3
+            )
+            chat_temp = gr.Slider(label="Temperature", minimum=0.0, maximum=1.0, value=0.5, step=0.1)
+            chat_btn = gr.Button("🚀 Ask K2 Think V2", variant="primary")
+            chat_output = gr.Textbox(label="K2 Think V2 Response", lines=25, max_lines=40)
+            
+            def direct_chat(question, temperature):
+                if not question.strip():
+                    return "Please enter a question."
+                client = K2ThinkClient()
+                messages = [{"role": "user", "content": question}]
+                return client.chat(messages, temperature=temperature, max_tokens=4096)
+            
+            chat_btn.click(
+                fn=direct_chat,
+                inputs=[chat_input, chat_temp],
+                outputs=[chat_output]
+            )
+        
+        # ── TAB 4: About ──
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown("""
+            ## AlphaForge x K2 Think V2
+            
+            Built for the **Build with K2 Think V2 Challenge** by MBZUAI.
+            
+            ### What This Demo Shows
+            
+            1. **Real-Time Market Data** — Fetch live stock prices, volume, OHLCV from Yahoo Finance
+            2. **Technical Analysis** — 14+ indicators: RSI, MACD, Bollinger, VWAP, Stochastic, ATR
+            3. **Alpha Signal Generation** — Composite scoring combining trend, momentum, volatility, volume
+            4. **Risk Metrics** — Sharpe, Sortino, VaR, CVaR, Calmar, max drawdown, skewness, kurtosis
+            5. **Portfolio Optimization** — Mean-variance optimization with efficient frontier visualization
+            6. **AI-Powered Analysis** — K2 Think V2 (MBZUAI's SOTA reasoning model) provides deep chain-of-thought analysis
+            
+            ### Architecture
+            
+            ```
+            ┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
+            │   yfinance      │────▶│  AlphaForge      │────▶│  K2 Think V2    │
+            │   (market data) │     │  (quant signals) │     │  (AI reasoning) │
+            └─────────────────┘     └──────────────────┘     └─────────────────┘
+            ```
+            
+            ### K2 Think V2 API
+            
+            - **Model**: MBZUAI-IFM/K2-Think-v2
+            - **Provider**: MBZUAI (Mohamed bin Zayed University of AI)
+            - **Features**: Chain-of-thought reasoning, deep financial analysis, multi-step logic
+            
+            ### Technologies
+            
+            - **Gradio** — Interactive web UI
+            - **yfinance** — Real-time market data
+            - **Plotly** — Interactive charts
+            - **K2 Think V2** — AI reasoning and analysis
+            
+            ### Links
+            
+            - [AlphaForge Quant System](https://huggingface.co/Premchan369/alphaforge-quant-system) — Full open-source quant platform (25 modules)
+            - [Build with K2 Think V2](https://build.k2think.ai/) — Official challenge page
+            - [MBZUAI](https://mbzuai.ac.ae/) — Mohamed bin Zayed University of AI
+            
+            ---
+            
+            *Built by Premchan | Built with K2 Think V2 Challenge*
+            """)
+    
+    return demo
+
+
+# ──────────────────────────────────────────────────────────────
+# Main Entry Point
+# ──────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    demo = build_app()
+    
+    # For HuggingFace Spaces
+    demo.queue().launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )