Full AlphaForge v2: 4 tabs, 14 indicators, K2 Think V2 integration, portfolio optimizer

app.py

@@ -1,10 +1,1056 @@
+"""
+AlphaForge x K2 Think V2 — Institutional-Grade Quantitative Analysis Platform
+Built for the "Build with K2 Think V2" Challenge by MBZUAI.
+"""
+
+import os
+import json
+import time
+import traceback
+from datetime import datetime, timedelta
+from typing import Optional, Dict, List, Tuple
+
+import numpy as np
+import pandas as pd
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import yfinance as yf
+import requests
 import gradio as gr
 
-with gr.Blocks(title="Hello Test") as demo:
-    gr.Markdown("# Hello World")
-    name = gr.Textbox(label="Your name")
-    output = gr.Textbox(label="Greeting")
-    button = gr.Button("Greet")
-    button.click(lambda x: f"Hello, {x}!", inputs=name, outputs=output)
+# ─── Configuration ───────────────────────────────────────────────────────────
+
+K2_API_URL = "https://api.k2think.ai/v1/chat/completions"
+K2_API_KEY = os.environ.get("K2_API_KEY", "")
+K2_MODEL = "MBZUAI-IFM/K2-Think-v2"
+
+APP_TITLE = "AlphaForge x K2 Think V2"
+APP_DESC = "Institutional-Grade Quantitative Analysis Platform"
+
+# ─── K2 Think V2 Client ─────────────────────────────────────────────────────
+
+def call_k2(messages: list, temperature: float = 0.3, max_tokens: int = 2048) -> str:
+    """Call the K2 Think V2 API with proper error handling."""
+    if not K2_API_KEY:
+        return "⚠️ K2_API_KEY not set. Add it as a Space secret in Settings."
+
+    headers = {
+        "Authorization": f"Bearer {K2_API_KEY}",
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+    }
+
+    payload = {
+        "model": K2_MODEL,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens
+    }
+
+    try:
+        response = requests.post(K2_API_URL, headers=headers, json=payload, timeout=120)
+
+        if response.status_code != 200:
+            return f"⚠️ API Error {response.status_code}: {response.text[:500]}"
+
+        # Handle streaming response
+        full_content = ""
+        for line in response.text.split('\n'):
+            line = line.strip()
+            if not line or line == 'data: [DONE]':
+                continue
+            if line.startswith('data: '):
+                line = line[6:]
+            try:
+                chunk = json.loads(line)
+                delta = chunk.get('choices', [{}])[0].get('delta', {})
+                if 'content' in delta:
+                    full_content += delta['content']
+            except (json.JSONDecodeError, KeyError, IndexError):
+                pass
+
+        # Try non-streaming fallback
+        if not full_content:
+            try:
+                data = response.json()
+                full_content = data.get('choices', [{}])[0].get('message', {}).get('content', '')
+            except (json.JSONDecodeError, KeyError):
+                pass
+
+        if not full_content:
+            return f"⚠️ Empty response from K2 Think V2. Raw: {response.text[:300]}"
+
+        return full_content.strip()
+
+    except requests.exceptions.Timeout:
+        return "⚠️ K2 Think V2 request timed out (120s). Try again or use a shorter question."
+    except Exception as e:
+        return f"⚠️ API Error: {str(e)}"
+
+
+def call_k2_non_streaming(messages: list, temperature: float = 0.3, max_tokens: int = 2048) -> str:
+    """Non-streaming fallback for K2 Think V2."""
+    if not K2_API_KEY:
+        return "⚠️ K2_API_KEY not set."
+
+    headers = {
+        "Authorization": f"Bearer {K2_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "model": K2_MODEL,
+        "messages": messages,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
+        "stream": False
+    }
+
+    try:
+        response = requests.post(K2_API_URL, headers=headers, json=payload, timeout=120)
+        if response.status_code != 200:
+            return f"⚠️ API Error {response.status_code}: {response.text[:500]}"
+        data = response.json()
+        content = data.get('choices', [{}])[0].get('message', {}).get('content', '')
+        return content.strip() if content else "⚠️ Empty response."
+    except Exception as e:
+        return f"⚠️ Error: {str(e)}"
+
+
+# ─── Data Layer ──────────────────────────────────────────────────────────────
+
+def fetch_stock_data(ticker: str, period: str = "1y") -> Tuple[Optional[pd.DataFrame], Optional[dict], str]:
+    """Fetch and compute all technical indicators for a single stock."""
+    info = {}
+    try:
+        stock = yf.Ticker(ticker)
+        df = stock.history(period=period)
+
+        if df.empty:
+            return None, None, f"No data found for {ticker}."
+
+        # Get stock info
+        try:
+            info_obj = stock.info
+            info = {
+                "name": info_obj.get("longName", ticker),
+                "sector": info_obj.get("sector", "N/A"),
+                "industry": info_obj.get("industry", "N/A"),
+                "market_cap": info_obj.get("marketCap", None),
+                "pe_ratio": info_obj.get("trailingPE", None),
+                "forward_pe": info_obj.get("forwardPE", None),
+                "dividend_yield": info_obj.get("dividendYield", None),
+                "beta": info_obj.get("beta", None),
+                "52w_high": info_obj.get("fiftyTwoWeekHigh", None),
+                "52w_low": info_obj.get("fiftyTwoWeekLow", None),
+                "avg_volume": info_obj.get("averageVolume", None),
+                "short_ratio": info_obj.get("shortRatio", None),
+            }
+        except Exception:
+            pass
+
+        # === Technical Indicators ===
+        close = df['Close'].astype(float)
+        high = df['High'].astype(float)
+        low = df['Low'].astype(float)
+        volume = df['Volume'].astype(float)
+
+        # SMA
+        df['SMA_20'] = close.rolling(20).mean()
+        df['SMA_50'] = close.rolling(50).mean()
+        df['SMA_200'] = close.rolling(200).mean()
+
+        # EMA
+        df['EMA_12'] = close.ewm(span=12, adjust=False).mean()
+        df['EMA_26'] = 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_Hist'] = df['MACD'] - df['MACD_Signal']
+
+        # RSI
+        delta = close.diff()
+        gain = delta.where(delta > 0, 0.0)
+        loss = -delta.where(delta < 0, 0.0)
+        avg_gain = gain.rolling(14).mean()
+        avg_loss = loss.rolling(14).mean()
+        rs = avg_gain / avg_loss
+        df['RSI'] = 100 - (100 / (1 + rs))
+
+        # Bollinger Bands
+        df['BB_Mid'] = close.rolling(20).mean()
+        bb_std = close.rolling(20).std()
+        df['BB_Upper'] = df['BB_Mid'] + 2 * bb_std
+        df['BB_Lower'] = df['BB_Mid'] - 2 * bb_std
+
+        # ATR
+        high_low = high - low
+        high_close = (high - close.shift()).abs()
+        low_close = (low - close.shift()).abs()
+        tr = pd.concat([high_low, high_close, low_close], axis=1).max(axis=1)
+        df['ATR'] = tr.rolling(14).mean()
+
+        # Stochastic
+        low_14 = low.rolling(14).min()
+        high_14 = high.rolling(14).max()
+        df['Stoch_K'] = 100 * (close - low_14) / (high_14 - low_14)
+        df['Stoch_D'] = df['Stoch_K'].rolling(3).mean()
+
+        # VWAP
+        df['VWAP'] = (df['Volume'] * (high + low + close) / 3).cumsum() / df['Volume'].cumsum()
+
+        # Volume Ratio
+        df['Vol_Ratio'] = volume / volume.rolling(20).mean()
+
+        # Daily returns
+        df['Returns'] = close.pct_change()
+        df['Log_Returns'] = np.log(close / close.shift(1))
+
+        # === Composite Alpha Signal (5 factors) ===
+        trend_score = ((df['SMA_20'] > df['SMA_50']).astype(float) * 0.5 +
+                       (df['SMA_50'] > df['SMA_200']).astype(float) * 0.3 +
+                       (close > df['SMA_20']).astype(float) * 0.2)
+
+        macd_score = ((df['MACD'] > df['MACD_Signal']).astype(float) * 0.5 +
+                      (df['MACD_Hist'] > 0).astype(float) * 0.5)
+
+        rsi_score = ((df['RSI'] < 30).astype(float) * 1.0 +
+                     ((df['RSI'] > 50) & (df['RSI'] < 70)).astype(float) * 0.5 +
+                     (df['RSI'] > 70).astype(float) * (-1.0))
+
+        vol_score = (df['Vol_Ratio'] > 1.5).astype(float)
+
+        price_score = ((close > df['VWAP']).astype(float) * 0.5 +
+                       (close > df['BB_Mid']).astype(float) * 0.3 +
+                       (close < df['BB_Lower']).astype(float) * 0.2)
+
+        df['Alpha_Score'] = (0.30 * trend_score + 0.20 * macd_score +
+                             0.20 * rsi_score + 0.15 * vol_score + 0.15 * price_score)
+
+        # Risk metrics
+        returns = df['Returns'].dropna()
+        rf = 0.05 / 252  # daily risk-free rate
+
+        sharpe = np.sqrt(252) * (returns.mean() - rf) / returns.std() if returns.std() > 0 else 0
+        downside = returns[returns < 0]
+        sortino = np.sqrt(252) * (returns.mean() - rf) / downside.std() if len(downside) > 0 and downside.std() > 0 else 0
+        var_95 = np.percentile(returns, 5)
+        cvar_95 = returns[returns <= var_95].mean() if len(returns[returns <= var_95]) > 0 else var_95
+        max_dd = (close / close.cummax() - 1).min()
+        calmar = (returns.mean() * 252) / abs(max_dd) if max_dd != 0 else 0
+        skewness = returns.skew()
+        kurtosis = returns.kurtosis()
+
+        risk_metrics = {
+            "sharpe": round(sharpe, 3),
+            "sortino": round(sortino, 3),
+            "var_95": f"{var_95:.4f}",
+            "cvar_95": f"{cvar_95:.4f}",
+            "max_drawdown": f"{max_dd:.4f}",
+            "calmar": round(calmar, 3),
+            "skewness": round(skewness, 3),
+            "kurtosis": round(kurtosis, 3),
+        }
+
+        # Current signals
+        latest = {
+            "price": f"${close.iloc[-1]:.2f}",
+            "change": f"{close.iloc[-1] - close.iloc[-2]:.2f}",
+            "change_pct": f"{(close.iloc[-1] / close.iloc[-2] - 1) * 100:.2f}%",
+            "rsi": round(df['RSI'].iloc[-1], 1) if not pd.isna(df['RSI'].iloc[-1]) else "N/A",
+            "macd": round(df['MACD'].iloc[-1], 3) if not pd.isna(df['MACD'].iloc[-1]) else "N/A",
+            "macd_signal": round(df['MACD_Signal'].iloc[-1], 3) if not pd.isna(df['MACD_Signal'].iloc[-1]) else "N/A",
+            "alpha_score": round(df['Alpha_Score'].iloc[-1], 3) if not pd.isna(df['Alpha_Score'].iloc[-1]) else "N/A",
+            "vol_ratio": round(df['Vol_Ratio'].iloc[-1], 2) if not pd.isna(df['Vol_Ratio'].iloc[-1]) else "N/A",
+            "atr": round(df['ATR'].iloc[-1], 2) if not pd.isna(df['ATR'].iloc[-1]) else "N/A",
+            "vwap": f"${df['VWAP'].iloc[-1]:.2f}" if not pd.isna(df['VWAP'].iloc[-1]) else "N/A",
+            "sma_20": f"${df['SMA_20'].iloc[-1]:.2f}" if not pd.isna(df['SMA_20'].iloc[-1]) else "N/A",
+            "sma_50": f"${df['SMA_50'].iloc[-1]:.2f}" if not pd.isna(df['SMA_50'].iloc[-1]) else "N/A",
+            "sma_200": f"${df['SMA_200'].iloc[-1]:.2f}" if not pd.isna(df['SMA_200'].iloc[-1]) else "N/A",
+            "stoch_k": round(df['Stoch_K'].iloc[-1], 1) if not pd.isna(df['Stoch_K'].iloc[-1]) else "N/A",
+        }
+
+        return df, {"info": info, "latest": latest, "risk": risk_metrics}, ""
+
+    except Exception as e:
+        return None, None, f"Error fetching {ticker}: {str(e)}"
+
+
+# ─── Visualization ───────────────────────────────────────────────────────────
+
+def make_candlestick_chart(df: pd.DataFrame, ticker: str) -> go.Figure:
+    """Create interactive candlestick chart with SMA and Bollinger Bands."""
+    fig = make_subplots(
+        rows=3, cols=1,
+        shared_xaxes=True,
+        vertical_spacing=0.03,
+        row_heights=[0.5, 0.25, 0.25],
+        subplot_titles=(f"{ticker} — Price & Bollinger Bands", "MACD", "RSI")
+    )
+
+    # Candlestick
+    fig.add_trace(
+        go.Candlestick(
+            x=df.index, open=df['Open'], high=df['High'],
+            low=df['Low'], close=df['Close'],
+            name="Price", showlegend=True
+        ), row=1, col=1
+    )
+
+    # Moving Averages
+    for sma, name, color in [('SMA_20', 'SMA 20', 'blue'), ('SMA_50', 'SMA 50', 'orange'), ('SMA_200', 'SMA 200', 'red')]:
+        if sma in df.columns and df[sma].notna().any():
+            fig.add_trace(go.Scatter(x=df.index, y=df[sma], mode='lines',
+                                     name=name, line=dict(color=color, width=1)),
+                          row=1, col=1)
+
+    # Bollinger Bands
+    if 'BB_Upper' in df.columns:
+        fig.add_trace(go.Scatter(x=df.index, y=df['BB_Upper'], mode='lines',
+                                 name='BB Upper', line=dict(color='gray', width=0.5, dash='dash'),
+                                 showlegend=False), row=1, col=1)
+        fig.add_trace(go.Scatter(x=df.index, y=df['BB_Lower'], mode='lines',
+                                 name='BB Lower', line=dict(color='gray', width=0.5, dash='dash'),
+                                 fill='tonexty', fillcolor='rgba(128,128,128,0.1)',
+                                 showlegend=False), row=1, col=1)
+
+    # MACD
+    if 'MACD' in df.columns:
+        fig.add_trace(go.Scatter(x=df.index, y=df['MACD'], mode='lines',
+                                 name='MACD', line=dict(color='blue', width=1)),
+                      row=2, col=1)
+        fig.add_trace(go.Scatter(x=df.index, y=df['MACD_Signal'], mode='lines',
+                                 name='Signal', line=dict(color='red', width=1)),
+                      row=2, col=1)
+        colors = ['green' if v >= 0 else 'red' for v in df['MACD_Hist'].fillna(0)]
+        fig.add_trace(go.Bar(x=df.index, y=df['MACD_Hist'], name='Histogram',
+                             marker_color=colors, showlegend=False),
+                      row=2, col=1)
+
+    # RSI
+    if 'RSI' in df.columns:
+        fig.add_trace(go.Scatter(x=df.index, y=df['RSI'], mode='lines',
+                                 name='RSI', line=dict(color='purple', width=1)),
+                      row=3, col=1)
+        fig.add_hline(y=70, line_dash="dash", line_color="red", opacity=0.5, row=3, col=1)
+        fig.add_hline(y=30, line_dash="dash", line_color="green", opacity=0.5, row=3, col=1)
+
+    fig.update_layout(
+        template='plotly_dark',
+        height=800,
+        hovermode='x unified',
+        showlegend=True,
+        margin=dict(l=40, r=40, t=60, b=40),
+        xaxis_rangeslider_visible=False,
+    )
+    fig.update_xaxes(title_text="Date", row=3, col=1)
+    fig.update_yaxes(title_text="Price ($)", row=1, col=1)
+    fig.update_yaxes(title_text="MACD", row=2, col=1)
+    fig.update_yaxes(title_text="RSI", row=3, col=1)
+
+    return fig
+
+
+def make_returns_chart(df: pd.DataFrame) -> go.Figure:
+    """Create returns distribution histogram."""
+    returns = df['Returns'].dropna()
+
+    fig = go.Figure()
+    fig.add_trace(go.Histogram(
+        x=returns, nbinsx=50, name='Daily Returns',
+        histnorm='probability density',
+        marker_color='rgba(100, 149, 237, 0.7)',
+        showlegend=True
+    ))
+
+    # Normal distribution overlay
+    x = np.linspace(returns.min(), returns.max(), 200)
+    y = (1 / (returns.std() * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - returns.mean()) / returns.std()) ** 2)
+    fig.add_trace(go.Scatter(x=x, y=y, mode='lines',
+                             name='Normal Distribution',
+                             line=dict(color='red', width=2)))
+
+    fig.update_layout(
+        template='plotly_dark',
+        title="Daily Returns Distribution vs Normal",
+        height=400,
+        margin=dict(l=40, r=40, t=60, b=40),
+    )
+    fig.update_xaxes(title_text="Daily Return")
+    fig.update_yaxes(title_text="Density")
+
+    return fig
+
+
+# ─── Portfolio Optimization ──────────────────────────────────────────────────
+
+def optimize_portfolio(tickers_str: str, period: str = "1y") -> Tuple:
+    """Mean-variance portfolio optimization with efficient frontier."""
+    tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()]
+
+    if len(tickers) < 2:
+        return None, None, None, "Enter at least 2 tickers (comma-separated)."
+
+    try:
+        data = yf.download(tickers, period=period)['Close']
+        if isinstance(data, pd.Series):
+            data = data.to_frame()
+
+        data = data.dropna()
+
+        if data.empty:
+            return None, None, None, "No overlapping data for these tickers."
+
+        returns = data.pct_change().dropna()
+        mean_returns = returns.mean() * 252
+        cov_matrix = returns.cov() * 252
+
+        n_assets = len(tickers)
+
+        # === Efficient frontier via random portfolios ===
+        n_portfolios = 5000
+        results = np.zeros((3, n_portfolios))
+        weights_record = []
+
+        np.random.seed(42)
+        for i in range(n_portfolios):
+            w = np.random.random(n_assets)
+            w /= w.sum()
+            weights_record.append(w)
+            portfolio_return = np.sum(w * mean_returns)
+            portfolio_std = np.sqrt(w @ cov_matrix @ w)
+            results[0, i] = portfolio_std
+            results[1, i] = portfolio_return
+            results[2, i] = portfolio_return / portfolio_std  # Sharpe
+
+        max_sharpe_idx = np.argmax(results[2])
+        max_sharpe_weights = weights_record[max_sharpe_idx]
+
+        # === Optimization: maximize Sharpe ===
+        from scipy.optimize import minimize
+
+        def neg_sharpe(w):
+            port_return = np.sum(w * mean_returns)
+            port_std = np.sqrt(w @ cov_matrix @ w)
+            return -port_return / port_std if port_std > 0 else 0
+
+        constraints = ({'type': 'eq', 'fun': lambda w: np.sum(w) - 1})
+        bounds = tuple((0, 0.5) for _ in range(n_assets))
+        init_guess = np.ones(n_assets) / n_assets
+
+        opt_result = minimize(neg_sharpe, init_guess, method='SLSQP',
+                              bounds=bounds, constraints=constraints)
+
+        opt_weights = opt_result.x if opt_result.success else max_sharpe_weights
+        opt_return = np.sum(opt_weights * mean_returns)
+        opt_std = np.sqrt(opt_weights @ cov_matrix @ opt_weights)
+        opt_sharpe = opt_return / opt_std if opt_std > 0 else 0
+
+        # === Efficient frontier chart ===
+        fig = go.Figure()
+        fig.add_trace(go.Scatter(
+            x=results[0], y=results[1],
+            mode='markers',
+            marker=dict(
+                size=5,
+                color=results[2],
+                colorscale='Viridis',
+                colorbar=dict(title='Sharpe Ratio'),
+                showscale=True
+            ),
+            name='Portfolios',
+            text=[f"Sharpe: {s:.3f}" for s in results[2]],
+            hovertemplate='Risk: %{x:.3f}<br>Return: %{y:.3f}<extra></extra>'
+        ))
+
+        fig.add_trace(go.Scatter(
+            x=[opt_std], y=[opt_return],
+            mode='markers',
+            marker=dict(size=15, color='red', symbol='star'),
+            name=f'Optimal (Sharpe: {opt_sharpe:.3f})'
+        ))
+
+        equal_weights = np.ones(n_assets) / n_assets
+        eq_return = np.sum(equal_weights * mean_returns)
+        eq_std = np.sqrt(equal_weights @ cov_matrix @ equal_weights)
+        fig.add_trace(go.Scatter(
+            x=[eq_std], y=[eq_return],
+            mode='markers',
+            marker=dict(size=12, color='orange', symbol='diamond'),
+            name=f'Equal Weight'
+        ))
+
+        fig.update_layout(
+            template='plotly_dark',
+            title=f"Efficient Frontier — {len(tickers)} Assets",
+            height=600,
+            xaxis_title="Risk (Annualized Std Dev)",
+            yaxis_title="Return (Annualized)",
+            hovermode='closest',
+            margin=dict(l=40, r=40, t=60, b=40),
+        )
+
+        # Weights table
+        weights_df = pd.DataFrame({
+            'Ticker': tickers,
+            'Optimal Weight': [f"{w:.2%}" for w in opt_weights],
+            'Equal Weight': [f"{1/n_assets:.2%}"] * n_assets,
+            'Difference': [f"{(w - 1/n_assets):.2%}" for w in opt_weights]
+        })
+
+        # Portfolio risk metrics
+        opt_returns_series = returns @ opt_weights
+        rf = 0.05 / 252
+        port_sharpe = np.sqrt(252) * (opt_returns_series.mean() - rf) / opt_returns_series.std()
+        port_max_dd = (1 + opt_returns_series).cumprod().div((1 + opt_returns_series).cumprod().cummax()) - 1
+        max_drawdown = port_max_dd.min()
+
+        port_metrics = {
+            "Expected Return": f"{opt_return:.2%}",
+            "Risk (Std Dev)": f"{opt_std:.2%}",
+            "Sharpe Ratio": f"{port_sharpe:.3f}",
+            "Max Drawdown": f"{max_drawdown:.2%}",
+            "Correlation Matrix": cov_matrix.corr().round(3).to_html(),
+        }
+
+        return fig, weights_df, port_metrics, ""
+
+    except Exception as e:
+        return None, None, None, f"Optimization error: {str(e)}"
+
+
+# ─── K2 Think Analysis ───────────────────────────────────────────────────────
+
+def analyze_stock_with_ai(ticker: str) -> str:
+    """K2 Think V2 deep analysis of a single stock."""
+    df, data, error = fetch_stock_data(ticker)
+    if error:
+        return f"❌ {error}"
+
+    if data is None:
+        return "❌ Could not retrieve data."
+
+    info = data.get("info", {})
+    latest = data.get("latest", {})
+    risk = data.get("risk", {})
+
+    data_summary = f"""
+Ticker: {ticker}
+Company: {info.get('name', ticker)}
+Sector: {info.get('sector', 'N/A')} | Industry: {info.get('industry', 'N/A')}
+Market Cap: {_fmt_billions(info.get('market_cap'))}
+P/E: {info.get('pe_ratio', 'N/A')} | Forward P/E: {info.get('forward_pe', 'N/A')}
+Beta: {info.get('beta', 'N/A')}
+52-Week Range: ${info.get('52w_low', 'N/A')} — ${info.get('52w_high', 'N/A')}
+"""
+
+    technical_summary = f"""
+Current Price: {latest.get('price', 'N/A')} ({latest.get('change_pct', 'N/A')})
+RSI (14): {latest.get('rsi', 'N/A')}
+MACD: {latest.get('macd', 'N/A')} vs Signal {latest.get('macd_signal', 'N/A')}
+Stochastic K: {latest.get('stoch_k', 'N/A')}
+VWAP: {latest.get('vwap', 'N/A')}
+SMA 20/50/200: {latest.get('sma_20', 'N/A')} / {latest.get('sma_50', 'N/A')} / {latest.get('sma_200', 'N/A')}
+Volume Ratio: {latest.get('vol_ratio', 'N/A')} (vs 20-day avg)
+ATR: ${latest.get('atr', 'N/A')}
+Alpha Score: {latest.get('alpha_score', 'N/A')}
+
+RISK METRICS:
+Sharpe: {risk.get('sharpe', 'N/A')} | Sortino: {risk.get('sortino', 'N/A')}
+VaR (95%): {risk.get('var_95', 'N/A')} | CVaR (95%): {risk.get('cvar_95', 'N/A')}
+Max Drawdown: {risk.get('max_drawdown', 'N/A')} | Calmar: {risk.get('calmar', 'N/A')}
+Skewness: {risk.get('skewness', 'N/A')} | Kurtosis: {risk.get('kurtosis', 'N/A')}
+"""
+
+    prompt = f"""You are an elite quantitative analyst at a top-tier hedge fund managing $5B AUM.
+
+Analyze {ticker} with deep, step-by-step reasoning.
+
+{data_summary}
+
+{technical_summary}
+
+Provide a comprehensive analysis following this structure:
+
+## 1. Executive Summary (3 bullets)
+- One sentence on the overall technical picture
+- Key risk factor to watch
+- Most important catalyst
+
+## 2. Technical Analysis Deep Dive
+- Interpret RSI in context (oversold/overbought/neutral and what it means)
+- MACD signal analysis (crossover, divergence, histogram momentum)
+- Moving average relationship (golden cross, death cross, or trending)
+- Volume analysis (accumulation vs distribution)
+- Bollinger Band position and squeeze/expansion
+- Alpha Score interpretation
+
+## 3. Risk Assessment
+- Current volatility regime (low/medium/high)
+- VaR interpretation and downside scenarios
+- Drawdown risk and recovery potential
+- Tail risk assessment (skewness/kurtosis)
+
+## 4. Alpha Signal
+- Direction: BULLISH / NEUTRAL / BEARISH
+- Confidence: low / medium / high
+- Time horizon: 1-week / 1-month / 3-month
+
+## 5. Actionable Trade Idea
+- Entry: specific price level with reasoning
+- Stop-loss: specific price level with reasoning  
+- Target: specific price level with reasoning
+- Position sizing recommendation (% of portfolio)
+- Risk-reward ratio
+
+## 6. Catalyst Watch
+- Upcoming events that could move the stock (earnings, economic reports, sector events)
+- Bull case catalyst
+- Bear case catalyst
+
+Format your response with clear markdown headers. Use specific numbers, not vague statements. Think step-by-step."""
+
+    messages = [
+        {"role": "system", "content": "You are an elite quantitative analyst. Always provide specific numbers, clear reasoning, and actionable insights. Use markdown formatting."},
+        {"role": "user", "content": prompt}
+    ]
+
+    try:
+        result = call_k2(messages, temperature=0.3, max_tokens=3072)
+        return result
+    except Exception as e:
+        # Try non-streaming fallback
+        try:
+            return call_k2_non_streaming(messages, temperature=0.3, max_tokens=3072)
+        except:
+            return f"❌ AI Analysis failed: {str(e)}"
+
+
+def analyze_portfolio_with_ai(tickers_str: str) -> str:
+    """K2 Think V2 portfolio analysis."""
+    tickers = [t.strip().upper() for t in tickers_str.split(',') if t.strip()]
+
+    if len(tickers) < 2:
+        return "Enter at least 2 tickers for portfolio analysis."
+
+    try:
+        data = yf.download(tickers, period="1y")['Close']
+        if isinstance(data, pd.Series):
+            data = data.to_frame()
+        data = data.dropna()
+        returns = data.pct_change().dropna()
+
+        # Portfolio metrics
+        equal_weights = np.ones(len(tickers)) / len(tickers)
+        port_returns = returns @ equal_weights
+        port_cum = (1 + port_returns).cumprod()
+
+        annual_return = port_returns.mean() * 252
+        annual_vol = port_returns.std() * np.sqrt(252)
+        sharpe = (annual_return - 0.05) / annual_vol if annual_vol > 0 else 0
+        max_dd = ((1 + port_returns).cumprod().div((1 + port_returns).cumprod().cummax()) - 1).min()
+
+        # Individual stock stats
+        stock_stats = []
+        for t in tickers:
+            r = returns[t]
+            stock_stats.append({
+                "ticker": t,
+                "ann_return": f"{r.mean() * 252:.2%}",
+                "ann_vol": f"{r.std() * np.sqrt(252):.2%}",
+                "sharpe": f"{(r.mean() * 252 - 0.05) / (r.std() * np.sqrt(252)):.2f}" if r.std() > 0 else "N/A",
+                "max_dd": f"{(1 + r).cumprod().div((1 + r).cumprod().cummax()).min():.2%}",
+            })
+
+        corr_matrix = returns.corr().round(3)
+
+        # Current prices
+        prices = {t: f"${data[t].iloc[-1]:.2f}" for t in tickers}
+
+        summary = f"""
+PORTFOLIO: {', '.join(tickers)}
+Period: 1 year
+
+EQUAL-WEIGHT METRICS:
+Annualized Return: {annual_return:.2%}
+Annualized Volatility: {annual_vol:.2%}
+Sharpe Ratio: {sharpe:.3f}
+Max Drawdown: {max_dd:.2%}
+
+STOCK STATS:
+{json.dumps(stock_stats, indent=2)}
+
+CORRELATION MATRIX:
+{corr_matrix.to_json(indent=2)}
+
+CURRENT PRICES:
+{json.dumps(prices, indent=2)}
+"""
+
+        prompt = f"""You are a portfolio manager at a multi-strategy hedge fund overseeing $500M AUM.
+
+Analyze this portfolio with institutional-grade rigor.
+
+{summary}
+
+Provide a comprehensive analysis:
+
+## 1. Portfolio Health Score (0-100)
+- Quantitative rating with letter grade (A+ to F)
+- Key drivers of the score
+- What would improve the score
+
+## 2. Concentration Risk Analysis
+- Sector/style concentration if evident
+- Single-name risk assessment
+- Diversification benefit analysis
+
+## 3. Correlation Matrix Insights
+- Most correlated pair and implications
+- Least correlated / negative correlated pair
+- Hedging opportunities from correlation structure
+
+## 4. Risk Budget Analysis
+- Contribution to portfolio risk by each position
+- Which stock drives most of the volatility
+- Tail risk concentration
+
+## 5. Rebalancing Recommendations
+- Specific % adjustments for each ticker
+- Reasoning for each adjustment
+- Expected impact on Sharpe
+
+## 6. Hedging Strategy
+- Specific options or ETFs to hedge tail risk
+- Cost of hedging vs benefit
+- When to implement the hedge
+
+## 7. Forward-Looking Assessment
+- Expected 6-month return and volatility
+- Key risks to the outlook
+- Scenario analysis (bull/base/bear)
+
+Use specific numbers and clear markdown formatting."""
+
+        messages = [
+            {"role": "system", "content": "You are an elite portfolio manager. Provide specific, quantitative, actionable advice with clear reasoning."},
+            {"role": "user", "content": prompt}
+        ]
+
+        try:
+            return call_k2(messages, temperature=0.3, max_tokens=3072)
+        except:
+            return call_k2_non_streaming(messages, temperature=0.3, max_tokens=3072)
+
+    except Exception as e:
+        return f"❌ Portfolio analysis error: {str(e)}"
+
+
+def chat_with_k2(message: str, temperature: float = 0.5) -> str:
+    """Direct chat with K2 Think V2."""
+    if not message.strip():
+        return "Please enter a question."
+
+    messages = [
+        {"role": "system", "content": "You are a helpful AI assistant specializing in quantitative finance, trading strategies, risk management, and financial markets. Provide detailed, accurate, and educational responses."},
+        {"role": "user", "content": message}
+    ]
+
+    try:
+        result = call_k2(messages, temperature=temperature, max_tokens=2048)
+        return result
+    except:
+        return call_k2_non_streaming(messages, temperature=temperature, max_tokens=2048)
+
+
+# ─── Helpers ─────────────────────────────────────────────────────────────────
+
+def _fmt_billions(val) -> str:
+    if val is None:
+        return "N/A"
+    if val >= 1e12:
+        return f"${val/1e12:.2f}T"
+    elif val >= 1e9:
+        return f"${val/1e9:.2f}B"
+    elif val >= 1e6:
+        return f"${val/1e6:.2f}M"
+    return f"${val:,.0f}"
+
+
+# ─── Gradio UI Handlers ──────────────────────────────────────────────────────
+
+def on_analyze(ticker: str):
+    """Handle single stock analysis."""
+    if not ticker.strip():
+        return None, None, None, "Please enter a ticker symbol."
+
+    ticker = ticker.strip().upper()
+    df, data, error = fetch_stock_data(ticker)
+
+    if error:
+        return None, None, None, f"❌ {error}"
+
+    chart = make_candlestick_chart(df, ticker)
+    returns_chart = make_returns_chart(df)
+
+    # Summary table
+    info = data.get("info", {})
+    latest = data.get("latest", {})
+    risk = data.get("risk", {})
+
+    summary = f"""
+### {info.get('name', ticker)} ({ticker})
+
+| Metric | Value |
+|--------|-------|
+| **Price** | {latest.get('price', 'N/A')} |
+| **Change** | {latest.get('change_pct', 'N/A')} |
+| **RSI** | {latest.get('rsi', 'N/A')} |
+| **MACD/Signal** | {latest.get('macd', 'N/A')} / {latest.get('macd_signal', 'N/A')} |
+| **Alpha Score** | {latest.get('alpha_score', 'N/A')} |
+| **SMA 20/50/200** | {latest.get('sma_20', 'N/A')} / {latest.get('sma_50', 'N/A')} / {latest.get('sma_200', 'N/A')} |
+| **VWAP** | {latest.get('vwap', 'N/A')} |
+| **Volume Ratio** | {latest.get('vol_ratio', 'N/A')} |
+| **ATR** | ${latest.get('atr', 'N/A')} |
+
+### Risk Metrics
+| Metric | Value |
+|--------|-------|
+| **Sharpe** | {risk.get('sharpe', 'N/A')} |
+| **Sortino** | {risk.get('sortino', 'N/A')} |
+| **VaR (95%)** | {risk.get('var_95', 'N/A')} |
+| **CVaR (95%)** | {risk.get('cvar_95', 'N/A')} |
+| **Max Drawdown** | {risk.get('max_drawdown', 'N/A')} |
+| **Calmar** | {risk.get('calmar', 'N/A')} |
+"""
+
+    return chart, returns_chart, summary, ""
+
+
+def on_ai_analysis(ticker: str):
+    """Run K2 Think V2 analysis."""
+    if not ticker.strip():
+        return "Please enter a ticker symbol."
+    result = analyze_stock_with_ai(ticker.strip().upper())
+    return result
+
+
+def on_portfolio_optimize(tickers_str: str):
+    """Handle portfolio optimization."""
+    fig, weights_df, metrics, error = optimize_portfolio(tickers_str)
+    if error:
+        return None, None, f"❌ {error}"
+    return fig, weights_df, ""
+
+
+def on_portfolio_ai(tickers_str: str):
+    """Run K2 Think V2 portfolio analysis."""
+    if not tickers_str.strip():
+        return "Please enter tickers."
+    result = analyze_portfolio_with_ai(tickers_str)
+    return result
+
+
+# ─── Gradio UI ───────────────────────────────────────────────────────────────
+
+def build_ui():
+    custom_css = """
+    .gradio-container { max-width: 1200px !important; margin: 0 auto !important; }
+    .k2-badge { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 4px 12px; border-radius: 12px; font-size: 0.8em; }
+    .metric-positive { color: #00ff88; font-weight: bold; }
+    .metric-negative { color: #ff4444; font-weight: bold; }
+    footer { visibility: hidden; }
+    """
+
+    with gr.Blocks(
+        title=APP_TITLE,
+        theme=gr.themes.Soft(primary_hue="blue", secondary_hue="purple"),
+        css=custom_css
+    ) as demo:
+        gr.Markdown(f"""
+        # 🔥 {APP_TITLE}
+        ### {APP_DESC}
+        > Powered by **K2 Think V2** (MBZUAI) — State-of-the-art reasoning for financial markets.
+        > Model compression powered by **Q-TensorFormer v3**.
+        """)
+
+        with gr.Tabs():
+            # ─── TAB 1: Single Stock Analysis ───
+            with gr.Tab("📈 Single Stock Analysis", id="stock"):
+                with gr.Row():
+                    ticker_input = gr.Textbox(
+                        label="Ticker Symbol",
+                        placeholder="Enter ticker (e.g., AAPL, NVDA, MSFT)",
+                        value="AAPL",
+                        scale=3
+                    )
+                    analyze_btn = gr.Button("🔍 Analyze", variant="primary", scale=1)
+                    ai_btn = gr.Button("🤖 AI Deep Analysis (K2 Think)", variant="secondary", scale=1)
+
+                with gr.Row():
+                    status = gr.Markdown("", visible=True)
+
+                with gr.Row():
+                    chart = gr.Plot(label="Price & Technicals", scale=2)
+                    with gr.Column(scale=1):
+                        summary = gr.Markdown(label="Summary", value="Enter a ticker to begin.")
+
+                with gr.Row():
+                    returns_chart = gr.Plot(label="Return Distribution", scale=1)
+
+                with gr.Row():
+                    ai_output = gr.Markdown(
+                        label="K2 Think V2 Deep Analysis",
+                        value="*Click 'AI Deep Analysis' for institutional-grade analysis powered by K2 Think V2.*",
+                        elem_classes=["ai-output"]
+                    )
+
+                analyze_btn.click(
+                    fn=on_analyze,
+                    inputs=[ticker_input],
+                    outputs=[chart, returns_chart, summary, status]
+                )
+                ai_btn.click(
+                    fn=on_ai_analysis,
+                    inputs=[ticker_input],
+                    outputs=[ai_output]
+                )
+
+            # ─── TAB 2: Portfolio Optimizer ───
+            with gr.Tab("💼 Portfolio Optimizer", id="portfolio"):
+                gr.Markdown("### Markowitz Mean-Variance Optimization")
+                with gr.Row():
+                    pf_input = gr.Textbox(
+                        label="Tickers (comma-separated)",
+                        placeholder="AAPL, MSFT, NVDA, GOOGL, AMZN",
+                        value="AAPL, MSFT, GOOGL, AMZN, NVDA",
+                        scale=4
+                    )
+                    pf_opt_btn = gr.Button("⚡ Optimize", variant="primary", scale=1)
+                    pf_ai_btn = gr.Button("🤖 AI Portfolio Advice (K2 Think)", variant="secondary", scale=1)
+
+                with gr.Row():
+                    pf_status = gr.Markdown("")
+
+                with gr.Row():
+                    ef_chart = gr.Plot(label="Efficient Frontier", scale=2)
+                    with gr.Column(scale=1):
+                        weights_table = gr.DataFrame(
+                            label="Portfolio Weights",
+                            headers=["Ticker", "Optimal Weight", "Equal Weight", "Difference"]
+                        )
+
+                with gr.Row():
+                    pf_ai_output = gr.Markdown(
+                        label="K2 Think V2 Portfolio Analysis",
+                        value="*Click 'AI Portfolio Advice' for institutional portfolio analysis.*"
+                    )
+
+                pf_opt_btn.click(
+                    fn=on_portfolio_optimize,
+                    inputs=[pf_input],
+                    outputs=[ef_chart, weights_table, pf_status]
+                )
+                pf_ai_btn.click(
+                    fn=on_portfolio_ai,
+                    inputs=[pf_input],
+                    outputs=[pf_ai_output]
+                )
+
+            # ─── TAB 3: Direct K2 Think Chat ───
+            with gr.Tab("💬 K2 Think V2 Chat", id="chat"):
+                gr.Markdown("### 💬 Ask K2 Think V2 Anything About Finance")
+                gr.Markdown("""
+                Ask about:
+                - **Trading strategies** (momentum, mean-reversion, pairs)
+                - **Portfolio theory** (Black-Litterman, risk parity)
+                - **Derivatives pricing** (Greeks, volatility surface)
+                - **Market microstructure** (order flow, liquidity)
+                - **Quant interview prep** (brain teasers, math, coding)
+                """)
+
+                with gr.Row():
+                    chat_input = gr.Textbox(
+                        label="Your Question",
+                        placeholder="Explain the Black-Scholes model and its limitations...",
+                        lines=3,
+                        scale=4
+                    )
+                with gr.Row():
+                    temp_slider = gr.Slider(
+                        label="Temperature", minimum=0.0, maximum=1.0, value=0.3, step=0.1,
+                        scale=1
+                    )
+                    chat_btn = gr.Button("🚀 Ask K2 Think", variant="primary", scale=1)
+
+                chat_output = gr.Markdown(
+                    label="K2 Think V2 Response",
+                    value="*Ask a question to get started.*"
+                )
+
+                chat_btn.click(
+                    fn=chat_with_k2,
+                    inputs=[chat_input, temp_slider],
+                    outputs=[chat_output]
+                )
+
+            # ─── TAB 4: About ───
+            with gr.Tab("ℹ️ About", id="about"):
+                gr.Markdown("""
+                ## 🔥 AlphaForge x K2 Think V2
+
+                **Institutional-Grade Quantitative Analysis Platform**
+
+                ### Powered By
+                - **K2 Think V2** — MBZUAI's state-of-the-art reasoning model for deep financial analysis
+                - **Q-TensorFormer v3** — Quantum-enhanced tensor network compression for efficient model deployment
+                - **yfinance** — Real-time market data from Yahoo Finance
+                - **Plotly** — Interactive financial visualizations
+                - **SciPy** — Portfolio optimization engine
+
+                ### Features
+                1. **Single Stock Analysis** — 14+ technical indicators, composite alpha signal, risk metrics
+                2. **AI Deep Analysis** — Institutional-grade analysis via K2 Think V2 chain-of-thought reasoning
+                3. **Portfolio Optimizer** — Markowitz mean-variance optimization with 5000-portfolio efficient frontier
+                4. **AI Portfolio Advice** — K2 Think V2 portfolio health scoring, rebalancing, and hedging strategies
+                5. **Direct K2 Chat** — Any financial question answered by SOTA reasoning model
+
+                ### Related Projects
+                - [Q-TensorFormer v3](https://huggingface.co/Premchan369/q-tensorformer) — Quantum+Tensor LLM compression
+                - [AlphaForge Platform](https://huggingface.co/Premchan369/alphaforge-quant-system) — 25 open-source quant modules
+                - [Build with K2 Think V2](https://build.k2think.ai/) — MBZUAI Challenge
+
+                ### Setup
+                1. Set `K2_API_KEY` as a Space secret in Settings
+                2. Factory Rebuild
+                3. Start analyzing!
+
+                ### License
+                Apache 2.0
+                """)
+
+        # ─── Footer ───
+        gr.Markdown("""
+        ---
+        <div align="center">
+        <small>AlphaForge x K2 Think V2 · Built for the Build with K2 Think V2 Challenge · MBZUAI</small><br>
+        <small>"From 'Can I see it?' → 'Can AI explain it?' → 'Can it run everywhere?'"</small>
+        </div>
+        """)
+
+    return demo
+
+
+# ─── Main ────────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    demo = build_ui()
+    demo.queue(max_size=10, default_concurrency_limit=3)
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+    )
 
-demo.launch(server_name="0.0.0.0", server_port=7860)