app.py

"""
LLM-Powered Multi-Agent Trading System
Author: Spencer Purdy
Description: A sophisticated multi-agent trading system leveraging real LLM reasoning for market analysis.
             Features specialized agents for fundamental, technical, sentiment analysis, and risk management,
             coordinated by a DQN reinforcement learning agent.
"""

# Install required packages
# !pip install -q transformers torch numpy pandas scikit-learn plotly gradio yfinance ta scipy gymnasium accelerate openai newsapi-python

# Core imports
import numpy as np
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from datetime import datetime, timedelta
import gradio as gr
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots
import json
import random
from typing import Dict, List, Tuple, Optional, Any
from dataclasses import dataclass
from collections import deque
import warnings
import os
import openai
from newsapi import NewsApiClient
warnings.filterwarnings('ignore')

# Technical analysis
import ta

# Transformers for sentiment analysis
from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    pipeline
)

# Set random seeds for reproducibility
np.random.seed(42)
torch.manual_seed(42)
random.seed(42)

# Configuration constants
TRADING_DAYS_PER_YEAR = 252
RISK_FREE_RATE = 0.02
MAX_POSITION_SIZE = 0.25  # Maximum 25% of portfolio in single position
MIN_CASH_RESERVE = 0.1    # Minimum 10% cash reserve

@dataclass
class MarketSignal:
    """Data class for agent signals"""
    agent_name: str
    signal_type: str  # 'buy', 'sell', 'hold'
    confidence: float  # 0-1
    reasoning: str
    metadata: Dict[str, Any]

@dataclass
class TradingDecision:
    """Data class for trading decisions"""
    action: str  # 'buy', 'sell', 'hold'
    size: float  # Position size as fraction of portfolio
    stop_loss: float
    take_profit: float
    confidence: float
    reasoning: Dict[str, str]

class BaseAgent:
    """Base class for all trading agents"""

    def __init__(self, name: str):
        self.name = name
        self.history = []

    def analyze(self, market_data: pd.DataFrame, portfolio_state: Dict) -> MarketSignal:
        """Analyze market data and return signal"""
        raise NotImplementedError

    def update_history(self, signal: MarketSignal, outcome: float):
        """Update agent history with signal and outcome"""
        self.history.append({
            'timestamp': datetime.now(),
            'signal': signal,
            'outcome': outcome
        })

class FundamentalAnalystAgent(BaseAgent):
    """Agent specializing in fundamental analysis using real OpenAI LLM reasoning"""

    def __init__(self, api_key: str):
        super().__init__("Fundamental Analyst")

        # Initialize OpenAI client
        self.api_key = api_key
        openai.api_key = self.api_key
        self.model = "gpt-3.5-turbo"  # Using GPT-3.5 for cost efficiency

        # System prompt for consistent analysis
        self.system_prompt = """You are a professional fundamental analyst with deep expertise in financial markets.
        Analyze the provided market data and give a clear trading recommendation (BUY, SELL, or HOLD) with detailed reasoning.
        Consider price movements, volume patterns, volatility, and market positioning.
        Be specific about the factors driving your recommendation and provide a confidence level (0-1).
        Format your response as:
        RECOMMENDATION: [BUY/SELL/HOLD]
        CONFIDENCE: [0.0-1.0]
        REASONING: [Your detailed analysis]"""

    def _prepare_market_analysis(self, market_data: pd.DataFrame, portfolio_state: Dict) -> str:
        """Prepare comprehensive market analysis for LLM"""

        # Calculate key metrics
        current_price = market_data['close'].iloc[-1]
        price_change_1d = market_data['close'].pct_change().iloc[-1] * 100
        price_change_5d = (market_data['close'].iloc[-1] / market_data['close'].iloc[-5] - 1) * 100
        price_change_20d = (market_data['close'].iloc[-1] / market_data['close'].iloc[-20] - 1) * 100

        # Volume analysis
        avg_volume_20d = market_data['volume'].iloc[-20:].mean()
        current_volume = market_data['volume'].iloc[-1]
        volume_ratio = current_volume / avg_volume_20d

        # Price metrics
        high_20d = market_data['high'].iloc[-20:].max()
        low_20d = market_data['low'].iloc[-20:].min()
        price_position = (current_price - low_20d) / (high_20d - low_20d) if high_20d > low_20d else 0.5

        # Moving averages
        ma_5 = market_data['close'].iloc[-5:].mean()
        ma_20 = market_data['close'].iloc[-20:].mean()
        ma_50 = market_data['close'].iloc[-50:].mean() if len(market_data) >= 50 else ma_20

        # Volatility
        returns = market_data['close'].pct_change()
        volatility = returns.iloc[-20:].std() * np.sqrt(252) * 100

        # Support and resistance levels
        support = market_data['low'].iloc[-20:].min()
        resistance = market_data['high'].iloc[-20:].max()

        # Portfolio context
        cash_ratio = portfolio_state.get('cash', 100000) / portfolio_state.get('total_value', 100000)

        analysis = f"""Market Analysis Report:

PRICE ACTION:
- Current Price: ${current_price:.2f}
- 1-Day Change: {price_change_1d:+.2f}%
- 5-Day Change: {price_change_5d:+.2f}%
- 20-Day Change: {price_change_20d:+.2f}%
- Position in 20-Day Range: {price_position:.1%} (0% = at low, 100% = at high)

TECHNICAL LEVELS:
- 5-Day MA: ${ma_5:.2f} ({'+' if current_price > ma_5 else '-'}{abs(current_price/ma_5 - 1)*100:.1f}%)
- 20-Day MA: ${ma_20:.2f} ({'+' if current_price > ma_20 else '-'}{abs(current_price/ma_20 - 1)*100:.1f}%)
- 50-Day MA: ${ma_50:.2f} ({'+' if current_price > ma_50 else '-'}{abs(current_price/ma_50 - 1)*100:.1f}%)
- Support Level: ${support:.2f}
- Resistance Level: ${resistance:.2f}

VOLUME ANALYSIS:
- Current Volume: {current_volume:,.0f}
- Volume vs 20-Day Average: {volume_ratio:.2f}x
- Volume Trend: {'High' if volume_ratio > 1.5 else 'Above Average' if volume_ratio > 1.2 else 'Average' if volume_ratio > 0.8 else 'Below Average'}

RISK METRICS:
- Annualized Volatility: {volatility:.1f}%
- Risk Level: {'High' if volatility > 30 else 'Moderate' if volatility > 20 else 'Low'}

PORTFOLIO CONTEXT:
- Cash Available: {cash_ratio:.1%} of portfolio
- Risk Capacity: {'High' if cash_ratio > 0.3 else 'Moderate' if cash_ratio > 0.15 else 'Low'}

Based on this comprehensive analysis, provide your trading recommendation."""

        return analysis

    def analyze(self, market_data: pd.DataFrame, portfolio_state: Dict) -> MarketSignal:
        """Perform fundamental analysis using OpenAI LLM"""

        # Prepare market analysis
        market_analysis = self._prepare_market_analysis(market_data, portfolio_state)

        try:
            # Call OpenAI API for analysis
            response = openai.ChatCompletion.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": self.system_prompt},
                    {"role": "user", "content": market_analysis}
                ],
                temperature=0.3,  # Lower temperature for more consistent analysis
                max_tokens=500
            )

            # Extract LLM response
            llm_analysis = response.choices[0].message.content

            # Parse the response
            lines = llm_analysis.split('\n')
            recommendation = 'hold'
            confidence = 0.5
            reasoning = ""

            for line in lines:
                if line.startswith('RECOMMENDATION:'):
                    rec_text = line.split(':', 1)[1].strip().upper()
                    if 'BUY' in rec_text:
                        recommendation = 'buy'
                    elif 'SELL' in rec_text:
                        recommendation = 'sell'
                    else:
                        recommendation = 'hold'
                elif line.startswith('CONFIDENCE:'):
                    try:
                        confidence = float(line.split(':', 1)[1].strip())
                        confidence = max(0.0, min(1.0, confidence))  # Ensure within bounds
                    except:
                        confidence = 0.5
                elif line.startswith('REASONING:'):
                    reasoning = line.split(':', 1)[1].strip()
                elif reasoning and line.strip():  # Continue reasoning on subsequent lines
                    reasoning += " " + line.strip()

            # Ensure we have valid reasoning
            if not reasoning:
                reasoning = "LLM analysis suggests " + recommendation + " based on current market conditions."

        except Exception as e:
            print(f"OpenAI API error: {e}")
            # Fallback to rule-based analysis if API fails
            returns = market_data['close'].pct_change()
            recent_return = returns.iloc[-20:].mean()

            if recent_return > 0.001:
                recommendation = 'buy'
                confidence = 0.6
                reasoning = "Positive momentum detected in recent price action based on technical indicators"
            elif recent_return < -0.001:
                recommendation = 'sell'
                confidence = 0.6
                reasoning = "Negative momentum suggests caution based on recent price movements"
            else:
                recommendation = 'hold'
                confidence = 0.5
                reasoning = "Market showing neutral patterns, maintaining current position"

        # Extract numerical data for metadata
        current_price = market_data['close'].iloc[-1]
        price_change = market_data['close'].pct_change().iloc[-1]

        return MarketSignal(
            agent_name=self.name,
            signal_type=recommendation,
            confidence=confidence,
            reasoning=reasoning,
            metadata={
                'current_price': round(current_price, 2),
                'price_change': round(price_change, 4),
                'llm_model': self.model,
                'analysis_timestamp': datetime.now().isoformat()
            }
        )

class TechnicalAnalystAgent(BaseAgent):
    """Agent specializing in technical analysis using numerical transformers"""

    def __init__(self):
        super().__init__("Technical Analyst")
        self.lookback_period = 20
        self.transformer_model = self._build_price_transformer()

    def _build_price_transformer(self):
        """Build a transformer model for price prediction"""
        class PriceTransformer(nn.Module):
            def __init__(self, input_dim=7, hidden_dim=64, num_heads=4, num_layers=2):
                super().__init__()
                self.input_projection = nn.Linear(input_dim, hidden_dim)
                self.positional_encoding = nn.Parameter(torch.randn(1, 100, hidden_dim))
                encoder_layer = nn.TransformerEncoderLayer(
                    d_model=hidden_dim,
                    nhead=num_heads,
                    dim_feedforward=hidden_dim * 4,
                    dropout=0.1,
                    batch_first=True
                )
                self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
                self.output_projection = nn.Linear(hidden_dim, 3)  # Buy, Hold, Sell

            def forward(self, x):
                x = self.input_projection(x)
                seq_len = x.size(1)
                x = x + self.positional_encoding[:, :seq_len, :]
                x = self.transformer(x)
                x = self.output_projection(x[:, -1, :])  # Use last timestep
                return torch.softmax(x, dim=-1)

        return PriceTransformer()

    def analyze(self, market_data: pd.DataFrame, portfolio_state: Dict) -> MarketSignal:
        """Perform technical analysis using indicators and transformer model"""

        # Calculate technical indicators
        df = market_data.copy()

        # Add technical indicators using ta library
        df['rsi'] = ta.momentum.RSIIndicator(df['close']).rsi()
        df['macd'] = ta.trend.MACD(df['close']).macd()
        df['bb_high'] = ta.volatility.BollingerBands(df['close']).bollinger_hband()
        df['bb_low'] = ta.volatility.BollingerBands(df['close']).bollinger_lband()
        df['volume_sma'] = df['volume'].rolling(window=20).mean()

        # Prepare features for transformer
        features = ['open', 'high', 'low', 'close', 'volume', 'rsi', 'macd']

        # Get last lookback_period rows
        recent_data = df[features].iloc[-self.lookback_period:].fillna(method='ffill').fillna(0)

        # Normalize features
        normalized_data = (recent_data - recent_data.mean()) / (recent_data.std() + 1e-8)

        # Convert to tensor
        input_tensor = torch.FloatTensor(normalized_data.values).unsqueeze(0)

        # Get transformer prediction
        with torch.no_grad():
            predictions = self.transformer_model(input_tensor)
            buy_prob, hold_prob, sell_prob = predictions[0].numpy()

        # Determine signal based on transformer output
        if buy_prob > 0.6:
            signal_type = 'buy'
            confidence = float(buy_prob)
            reasoning = "Strong bullish technical setup detected by transformer model"
        elif sell_prob > 0.6:
            signal_type = 'sell'
            confidence = float(sell_prob)
            reasoning = "Bearish technical pattern identified by transformer model"
        else:
            signal_type = 'hold'
            confidence = float(hold_prob)
            reasoning = "No clear technical direction detected"

        # Enhance reasoning with specific technical indicators
        current_rsi = df['rsi'].iloc[-1]
        if current_rsi < 30 and signal_type != 'buy':
            reasoning += f" (Note: RSI at {current_rsi:.1f} indicates oversold conditions)"
        elif current_rsi > 70 and signal_type != 'sell':
            reasoning += f" (Note: RSI at {current_rsi:.1f} indicates overbought conditions)"

        # Check Bollinger Bands
        current_price = df['close'].iloc[-1]
        bb_high = df['bb_high'].iloc[-1]
        bb_low = df['bb_low'].iloc[-1]

        if not np.isnan(bb_high) and not np.isnan(bb_low):
            if current_price > bb_high:
                reasoning += " Price breaking above upper Bollinger Band"
            elif current_price < bb_low:
                reasoning += " Price breaking below lower Bollinger Band"

        # MACD analysis
        macd_value = df['macd'].iloc[-1]
        macd_signal = ta.trend.MACD(df['close']).macd_signal().iloc[-1]

        if not np.isnan(macd_value) and not np.isnan(macd_signal):
            if macd_value > macd_signal and macd_value > 0:
                reasoning += " MACD showing bullish crossover above zero"
            elif macd_value < macd_signal and macd_value < 0:
                reasoning += " MACD showing bearish crossover below zero"

        return MarketSignal(
            agent_name=self.name,
            signal_type=signal_type,
            confidence=confidence,
            reasoning=reasoning,
            metadata={
                'rsi': round(current_rsi, 2) if not np.isnan(current_rsi) else 50,
                'buy_probability': round(buy_prob, 3),
                'sell_probability': round(sell_prob, 3),
                'hold_probability': round(hold_prob, 3),
                'current_price': round(current_price, 2),
                'bb_position': 'above' if current_price > bb_high else 'below' if current_price < bb_low else 'within'
            }
        )

class SentimentAnalystAgent(BaseAgent):
    """Agent specializing in sentiment analysis using FinBERT and real news data"""

    def __init__(self, news_api_key: str = None):
        super().__init__("Sentiment Analyst")
        # Initialize FinBERT for financial sentiment analysis
        self.tokenizer = AutoTokenizer.from_pretrained("ProsusAI/finbert")
        self.model = AutoModelForSequenceClassification.from_pretrained("ProsusAI/finbert")
        self.sentiment_pipeline = pipeline(
            "sentiment-analysis",
            model=self.model,
            tokenizer=self.tokenizer,
            device=-1  # CPU
        )

        # Initialize news API client
        self.news_api_key = news_api_key
        if self.news_api_key:
            self.newsapi = NewsApiClient(api_key=self.news_api_key)
        else:
            self.newsapi = None

    def _fetch_real_news(self, symbol: str = None) -> List[str]:
        """Fetch real news articles from NewsAPI"""

        if not self.newsapi:
            return self._generate_contextual_news()

        try:
            # Search for financial news
            query = f"stock market {symbol if symbol else 'trading'} finance"

            # Get top headlines
            headlines = self.newsapi.get_top_headlines(
                q=query,
                category='business',
                language='en',
                page_size=10
            )

            # Extract article titles and descriptions
            news_items = []

            if headlines['status'] == 'ok' and headlines['articles']:
                for article in headlines['articles'][:10]:
                    if article['title']:
                        news_items.append(article['title'])
                    if article['description']:
                        news_items.append(article['description'])

            # If not enough news, get everything
            if len(news_items) < 5:
                all_articles = self.newsapi.get_everything(
                    q=query,
                    language='en',
                    sort_by='relevancy',
                    page_size=10
                )

                if all_articles['status'] == 'ok' and all_articles['articles']:
                    for article in all_articles['articles']:
                        if article['title'] and article['title'] not in news_items:
                            news_items.append(article['title'])
                        if len(news_items) >= 10:
                            break

            return news_items[:10] if news_items else self._generate_contextual_news()

        except Exception as e:
            print(f"News API error: {e}")
            return self._generate_contextual_news()

    def _generate_contextual_news(self) -> List[str]:
        """Generate contextual market news as fallback"""

        base_headlines = [
            "Federal Reserve signals potential rate changes amid economic uncertainty",
            "Tech stocks rally as earnings season approaches",
            "Global markets react to latest inflation data",
            "Energy sector sees volatility amid geopolitical tensions",
            "Analysts upgrade outlook for financial sector",
            "Retail sales data exceeds expectations",
            "Manufacturing index shows signs of recovery",
            "Currency markets stabilize after central bank interventions",
            "Commodity prices surge on supply chain concerns",
            "Corporate earnings beat analyst estimates"
        ]

        # Add some variation
        selected = random.sample(base_headlines, min(5, len(base_headlines)))
        return selected

    def analyze(self, market_data: pd.DataFrame, portfolio_state: Dict) -> MarketSignal:
        """Perform sentiment analysis on real or contextual news"""

        # Fetch news items
        news_items = self._fetch_real_news()

        # Analyze sentiment for each news item
        sentiments = []
        for news in news_items:
            try:
                # Truncate to 512 characters for FinBERT
                result = self.sentiment_pipeline(news[:512])[0]
                sentiments.append(result)
            except Exception as e:
                print(f"Sentiment analysis error: {e}")
                sentiments.append({'label': 'neutral', 'score': 0.5})

        # Aggregate sentiments
        positive_count = sum(1 for s in sentiments if s['label'] == 'positive')
        negative_count = sum(1 for s in sentiments if s['label'] == 'negative')
        neutral_count = sum(1 for s in sentiments if s['label'] == 'neutral')

        # Calculate weighted scores
        positive_scores = [s['score'] for s in sentiments if s['label'] == 'positive']
        negative_scores = [s['score'] for s in sentiments if s['label'] == 'negative']

        positive_score = sum(positive_scores) / len(sentiments) if sentiments else 0
        negative_score = sum(negative_scores) / len(sentiments) if sentiments else 0
        neutral_score = 1 - positive_score - negative_score

        # Calculate net sentiment
        net_sentiment = positive_score - negative_score

        # Determine signal based on sentiment analysis
        if net_sentiment > 0.2 and positive_count > negative_count * 1.5:
            signal_type = 'buy'
            confidence = min(0.8, positive_score + 0.2)
            reasoning = f"Positive sentiment detected across {positive_count}/{len(sentiments)} news items"
        elif net_sentiment < -0.2 and negative_count > positive_count * 1.5:
            signal_type = 'sell'
            confidence = min(0.8, negative_score + 0.2)
            reasoning = f"Negative sentiment dominates with {negative_count}/{len(sentiments)} bearish news items"
        else:
            signal_type = 'hold'
            confidence = 0.5 + abs(net_sentiment) * 0.3
            reasoning = "Mixed sentiment suggests maintaining current position"

        # Add specific news context to reasoning
        if news_items and len(news_items) > 0:
            reasoning += f". Key headline: '{news_items[0][:100]}...'"

        # Consider market context
        recent_volatility = market_data['close'].pct_change().iloc[-20:].std()
        if recent_volatility > 0.02:
            confidence *= 0.9  # Reduce confidence in high volatility
            reasoning += " (Confidence adjusted for high market volatility)"

        return MarketSignal(
            agent_name=self.name,
            signal_type=signal_type,
            confidence=confidence,
            reasoning=reasoning,
            metadata={
                'positive_sentiment': round(positive_score, 3),
                'negative_sentiment': round(negative_score, 3),
                'neutral_sentiment': round(neutral_score, 3),
                'net_sentiment': round(net_sentiment, 3),
                'news_analyzed': len(news_items),
                'sentiment_distribution': {
                    'positive': positive_count,
                    'negative': negative_count,
                    'neutral': neutral_count
                },
                'data_source': 'real_news' if self.newsapi else 'contextual'
            }
        )

class RiskManagerAgent(BaseAgent):
    """Agent specializing in risk management and position sizing"""

    def __init__(self):
        super().__init__("Risk Manager")
        self.max_drawdown_threshold = 0.15  # 15% max drawdown
        self.var_confidence = 0.95  # 95% VaR

    def calculate_var(self, returns: pd.Series, confidence: float = 0.95) -> float:
        """Calculate Value at Risk"""
        if len(returns) < 20:
            return 0.02  # Default 2% VaR if insufficient data
        return np.percentile(returns, (1 - confidence) * 100)

    def calculate_sharpe_ratio(self, returns: pd.Series) -> float:
        """Calculate Sharpe ratio"""
        if len(returns) < 2:
            return 0.0
        excess_returns = returns - RISK_FREE_RATE / TRADING_DAYS_PER_YEAR
        return np.sqrt(TRADING_DAYS_PER_YEAR) * excess_returns.mean() / (returns.std() + 1e-8)

    def analyze(self, market_data: pd.DataFrame, portfolio_state: Dict) -> MarketSignal:
        """Perform risk analysis and provide risk-adjusted recommendations"""

        returns = market_data['close'].pct_change().dropna()
        current_price = market_data['close'].iloc[-1]

        # Calculate comprehensive risk metrics
        volatility = returns.iloc[-20:].std() * np.sqrt(TRADING_DAYS_PER_YEAR)
        var = self.calculate_var(returns.iloc[-100:])
        sharpe = self.calculate_sharpe_ratio(returns.iloc[-60:])

        # Calculate maximum drawdown
        cum_returns = (1 + returns).cumprod()
        running_max = cum_returns.expanding().max()
        drawdown = (cum_returns - running_max) / running_max
        max_drawdown = abs(drawdown.min())

        # Check portfolio metrics
        current_positions = portfolio_state.get('total_position_value', 0)
        portfolio_value = portfolio_state.get('total_value', 100000)
        cash_ratio = portfolio_state.get('cash', portfolio_value) / portfolio_value

        # Calculate current portfolio drawdown
        if 'peak_value' in portfolio_state:
            current_drawdown = (portfolio_state['peak_value'] - portfolio_value) / portfolio_state['peak_value']
        else:
            current_drawdown = 0

        # Comprehensive risk assessment
        risk_factors = []
        risk_score = 0

        if volatility > 0.3:  # High volatility
            risk_factors.append("high_volatility")
            risk_score += 2

        if current_drawdown > self.max_drawdown_threshold * 0.8:
            risk_factors.append("approaching_max_drawdown")
            risk_score += 3

        if cash_ratio < MIN_CASH_RESERVE:
            risk_factors.append("low_cash_reserves")
            risk_score += 2

        if sharpe < 0.5:
            risk_factors.append("poor_risk_adjusted_returns")
            risk_score += 1

        if var < -0.05:  # 5% VaR threshold
            risk_factors.append("high_value_at_risk")
            risk_score += 2

        # Kelly Criterion for position sizing
        win_rate = (returns > 0).mean()
        avg_win = returns[returns > 0].mean() if (returns > 0).any() else 0
        avg_loss = abs(returns[returns < 0].mean()) if (returns < 0).any() else 1

        kelly_fraction = 0
        if avg_loss > 0 and win_rate > 0:
            odds = avg_win / avg_loss
            kelly_fraction = (win_rate * odds - (1 - win_rate)) / odds
            kelly_fraction = max(0, min(kelly_fraction, 0.25))  # Cap at 25%

        # Determine signal based on comprehensive risk assessment
        if risk_score >= 5:
            signal_type = 'sell'
            confidence = min(0.7 + risk_score * 0.05, 0.9)
            reasoning = f"Multiple risk factors detected ({len(risk_factors)}): {', '.join(risk_factors)}. Risk score: {risk_score}/10"
        elif risk_score >= 3:
            signal_type = 'hold'
            confidence = 0.6
            reasoning = f"Elevated risk levels detected. Factors: {', '.join(risk_factors)}. Recommend caution"
        else:
            # Low risk environment - check for opportunities
            if sharpe > 1.0 and volatility < 0.2 and cash_ratio > 0.2:
                signal_type = 'buy'
                confidence = 0.7
                reasoning = f"Risk metrics favorable. Sharpe: {sharpe:.2f}, Vol: {volatility:.1%}, Cash available"
            else:
                signal_type = 'hold'
                confidence = 0.5
                reasoning = "Risk levels acceptable, maintaining current exposure"

        # Add Kelly Criterion to reasoning
        if kelly_fraction > 0:
            reasoning += f". Optimal position size (Kelly): {kelly_fraction:.1%}"

        return MarketSignal(
            agent_name=self.name,
            signal_type=signal_type,
            confidence=min(confidence, 0.9),
            reasoning=reasoning,
            metadata={
                'volatility': round(volatility, 3),
                'var_95': round(var, 3),
                'sharpe_ratio': round(sharpe, 2),
                'max_drawdown': round(max_drawdown, 3),
                'current_drawdown': round(current_drawdown, 3),
                'risk_factors': risk_factors,
                'risk_score': risk_score,
                'cash_ratio': round(cash_ratio, 2),
                'kelly_fraction': round(kelly_fraction, 3),
                'win_rate': round(win_rate, 2)
            }
        )

# DQN Implementation for Multi-Agent Coordination
class DQN(nn.Module):
    """Deep Q-Network for learning from agent recommendations"""

    def __init__(self, state_size: int, action_size: int):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(state_size, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 32)
        self.fc4 = nn.Linear(32, action_size)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = torch.relu(self.fc3(x))
        return self.fc4(x)

class ReinforcementLearningAgent:
    """DQN agent that learns from multi-agent recommendations"""

    def __init__(self, state_size: int = 16, action_size: int = 3):
        self.state_size = state_size
        self.action_size = action_size
        self.memory = deque(maxlen=2000)
        self.epsilon = 0.1  # Exploration rate
        self.gamma = 0.95   # Discount factor
        self.learning_rate = 0.001

        # Neural networks
        self.q_network = DQN(state_size, action_size)
        self.target_network = DQN(state_size, action_size)
        self.optimizer = optim.Adam(self.q_network.parameters(), lr=self.learning_rate)

        # Update target network
        self.update_target_network()

    def update_target_network(self):
        """Copy weights from main network to target network"""
        self.target_network.load_state_dict(self.q_network.state_dict())

    def remember(self, state, action, reward, next_state, done):
        """Store experience in replay memory"""
        self.memory.append((state, action, reward, next_state, done))

    def act(self, state):
        """Choose action based on epsilon-greedy policy"""
        if random.random() <= self.epsilon:
            return random.randrange(self.action_size)

        state_tensor = torch.FloatTensor(state).unsqueeze(0)
        q_values = self.q_network(state_tensor)
        return np.argmax(q_values.detach().numpy())

    def replay(self, batch_size: int = 32):
        """Train the model on a batch of experiences"""
        if len(self.memory) < batch_size:
            return

        batch = random.sample(self.memory, batch_size)
        states = torch.FloatTensor([e[0] for e in batch])
        actions = torch.LongTensor([e[1] for e in batch])
        rewards = torch.FloatTensor([e[2] for e in batch])
        next_states = torch.FloatTensor([e[3] for e in batch])
        dones = torch.FloatTensor([e[4] for e in batch])

        current_q_values = self.q_network(states).gather(1, actions.unsqueeze(1))
        next_q_values = self.target_network(next_states).max(1)[0].detach()
        target_q_values = rewards + (self.gamma * next_q_values * (1 - dones))

        loss = nn.MSELoss()(current_q_values.squeeze(), target_q_values)

        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()

class MultiAgentTradingSystem:
    """Main trading system coordinating multiple agents"""

    def __init__(self, initial_capital: float = 100000, openai_api_key: str = None, news_api_key: str = None):
        self.initial_capital = initial_capital
        self.openai_api_key = openai_api_key
        self.news_api_key = news_api_key
        self.reset()

        # Initialize agents
        print("Initializing trading agents...")

        # Check for API keys
        if not self.openai_api_key:
            print("Warning: OpenAI API key not provided. Fundamental analysis will use fallback methods.")

        if not self.news_api_key:
            print("Warning: News API key not provided. Sentiment analysis will use contextual news.")

        self.fundamental_agent = FundamentalAnalystAgent(self.openai_api_key)
        self.technical_agent = TechnicalAnalystAgent()
        self.sentiment_agent = SentimentAnalystAgent(self.news_api_key)
        self.risk_agent = RiskManagerAgent()

        print("All agents initialized successfully")

        # Initialize RL coordinator
        self.rl_agent = ReinforcementLearningAgent(state_size=16, action_size=3)

        # Trading history
        self.trade_history = []
        self.performance_history = []

    def reset(self):
        """Reset portfolio to initial state"""
        self.portfolio = {
            'cash': self.initial_capital,
            'positions': {},
            'total_value': self.initial_capital,
            'peak_value': self.initial_capital,
            'total_position_value': 0
        }

    def get_portfolio_value(self, current_prices: Dict[str, float]) -> float:
        """Calculate total portfolio value"""
        total = self.portfolio['cash']
        for symbol, position in self.portfolio['positions'].items():
            if symbol in current_prices:
                total += position['shares'] * current_prices[symbol]
        return total

    def aggregate_signals(self, signals: List[MarketSignal]) -> Tuple[str, float, Dict]:
        """Aggregate signals from multiple agents using weighted voting"""
        buy_score = 0
        sell_score = 0
        hold_score = 0

        reasoning = {}

        # Weight signals by confidence
        for signal in signals:
            weight = signal.confidence
            reasoning[signal.agent_name] = {
                'signal': signal.signal_type,
                'confidence': signal.confidence,
                'reasoning': signal.reasoning
            }

            if signal.signal_type == 'buy':
                buy_score += weight
            elif signal.signal_type == 'sell':
                sell_score += weight
            else:
                hold_score += weight

        # Normalize scores
        total_score = buy_score + sell_score + hold_score
        if total_score > 0:
            buy_score /= total_score
            sell_score /= total_score
            hold_score /= total_score

        # Determine action based on weighted voting
        if buy_score > 0.5:
            action = 'buy'
            confidence = buy_score
        elif sell_score > 0.5:
            action = 'sell'
            confidence = sell_score
        else:
            action = 'hold'
            confidence = hold_score

        return action, confidence, reasoning

    def create_state_vector(self, market_data: pd.DataFrame, signals: List[MarketSignal]) -> np.ndarray:
        """Create state vector for RL agent"""

        # Market features
        returns = market_data['close'].pct_change()
        current_return = returns.iloc[-1]
        volatility = returns.iloc[-20:].std()
        momentum = returns.iloc[-20:].mean()

        # Technical indicators
        rsi = ta.momentum.RSIIndicator(market_data['close']).rsi().iloc[-1]

        # Signal features
        buy_signals = sum(1 for s in signals if s.signal_type == 'buy')
        sell_signals = sum(1 for s in signals if s.signal_type == 'sell')
        avg_confidence = np.mean([s.confidence for s in signals])

        # Portfolio features
        cash_ratio = self.portfolio['cash'] / self.portfolio['total_value']
        position_ratio = self.portfolio['total_position_value'] / self.portfolio['total_value']

        # Risk metrics from risk agent
        risk_metadata = next((s.metadata for s in signals if s.agent_name == "Risk Manager"), {})
        risk_score = risk_metadata.get('risk_score', 0) / 10.0  # Normalize

        # Create state vector
        state = np.array([
            current_return,
            volatility,
            momentum,
            rsi / 100.0 if not np.isnan(rsi) else 0.5,
            buy_signals / len(signals),
            sell_signals / len(signals),
            avg_confidence,
            cash_ratio,
            position_ratio,
            risk_score,
            # Agent-specific confidences
            signals[0].confidence,  # Fundamental
            signals[1].confidence,  # Technical
            signals[2].confidence,  # Sentiment
            signals[3].confidence,  # Risk
            0, 0  # Padding for consistent size
        ])

        return state[:self.rl_agent.state_size]

    def execute_trade(self, symbol: str, action: str, confidence: float,
                     current_price: float, reasoning: Dict) -> Dict:
        """Execute trading decision"""

        trade_result = {
            'timestamp': datetime.now(),
            'symbol': symbol,
            'action': action,
            'price': current_price,
            'confidence': confidence,
            'reasoning': reasoning,
            'executed': False,
            'shares': 0,
            'value': 0
        }

        if action == 'buy':
            # Calculate position size based on confidence and risk limits
            max_position_value = self.portfolio['total_value'] * MAX_POSITION_SIZE

            # Use Kelly Criterion from risk agent if available
            risk_metadata = reasoning.get('Risk Manager', {})
            if isinstance(risk_metadata, dict) and 'metadata' in reasoning['Risk Manager']:
                kelly_fraction = reasoning['Risk Manager']['metadata'].get('kelly_fraction', 0.1)
            else:
                kelly_fraction = 0.1

            position_value = min(
                self.portfolio['cash'] * confidence * kelly_fraction,
                max_position_value
            )

            if position_value > current_price:
                shares = int(position_value / current_price)
                cost = shares * current_price

                # Ensure minimum cash reserve
                if cost <= self.portfolio['cash'] * (1 - MIN_CASH_RESERVE):
                    # Execute buy
                    self.portfolio['cash'] -= cost

                    if symbol in self.portfolio['positions']:
                        # Update existing position
                        old_shares = self.portfolio['positions'][symbol]['shares']
                        old_avg_price = self.portfolio['positions'][symbol]['avg_price']
                        new_shares = old_shares + shares
                        new_avg_price = (old_avg_price * old_shares + cost) / new_shares

                        self.portfolio['positions'][symbol]['shares'] = new_shares
                        self.portfolio['positions'][symbol]['avg_price'] = new_avg_price
                    else:
                        # Create new position
                        self.portfolio['positions'][symbol] = {
                            'shares': shares,
                            'avg_price': current_price
                        }

                    trade_result['executed'] = True
                    trade_result['shares'] = shares
                    trade_result['value'] = cost

        elif action == 'sell' and symbol in self.portfolio['positions']:
            # Sell a portion of position based on confidence
            position = self.portfolio['positions'][symbol]
            shares_to_sell = int(position['shares'] * confidence * 0.5)

            if shares_to_sell > 0:
                revenue = shares_to_sell * current_price
                self.portfolio['cash'] += revenue
                position['shares'] -= shares_to_sell

                if position['shares'] == 0:
                    del self.portfolio['positions'][symbol]

                trade_result['executed'] = True
                trade_result['shares'] = -shares_to_sell
                trade_result['value'] = revenue

        # Update portfolio metrics
        self.portfolio['total_position_value'] = sum(
            pos['shares'] * pos['avg_price']
            for pos in self.portfolio['positions'].values()
        )

        return trade_result

class MarketSimulator:
    """Simulate realistic market data for demonstration"""

    def __init__(self, base_price: float = 100, volatility: float = 0.02):
        self.base_price = base_price
        self.volatility = volatility
        self.drift = 0.0001

    def generate_market_data(self, days: int = 252) -> pd.DataFrame:
        """Generate simulated market data with realistic patterns"""

        dates = pd.date_range(end=datetime.now(), periods=days, freq='D')

        # Generate price series using geometric Brownian motion
        returns = np.random.normal(self.drift, self.volatility, days)

        # Add market regimes
        regime_length = days // 4
        for i in range(0, days, regime_length):
            regime_type = i // regime_length % 4
            if regime_type == 0:  # Bull market
                returns[i:i+regime_length] += np.random.normal(0.0005, 0.0001, min(regime_length, days-i))
            elif regime_type == 1:  # Bear market
                returns[i:i+regime_length] += np.random.normal(-0.0005, 0.0001, min(regime_length, days-i))
            elif regime_type == 2:  # High volatility
                returns[i:i+regime_length] *= 1.5
            # regime_type == 3 is normal market

        price_series = self.base_price * np.exp(np.cumsum(returns))

        # Add some mean reversion
        ma_20 = pd.Series(price_series).rolling(20).mean()
        mean_reversion_strength = 0.1
        for i in range(20, len(price_series)):
            if not np.isnan(ma_20.iloc[i]):
                deviation = (price_series[i] - ma_20.iloc[i]) / ma_20.iloc[i]
                price_series[i] *= (1 - mean_reversion_strength * deviation)

        # Generate OHLCV data
        data = {
            'date': dates,
            'open': price_series * np.random.uniform(0.99, 1.01, days),
            'high': price_series * np.random.uniform(1.01, 1.03, days),
            'low': price_series * np.random.uniform(0.97, 0.99, days),
            'close': price_series,
            'volume': np.random.lognormal(np.log(1000000), 0.5, days)
        }

        df = pd.DataFrame(data)
        df.set_index('date', inplace=True)

        # Ensure OHLC consistency
        df['high'] = df[['open', 'high', 'close']].max(axis=1)
        df['low'] = df[['open', 'low', 'close']].min(axis=1)

        return df

def run_backtest(trading_system: MultiAgentTradingSystem,
                 market_data: pd.DataFrame,
                 symbol: str = "DEMO") -> Tuple[pd.DataFrame, List[Dict]]:
    """Run comprehensive backtest simulation"""

    performance_history = []
    trade_history = []

    # Run simulation day by day
    print("Starting backtest simulation...")
    for i in range(50, len(market_data)):
        # Progress indicator
        if i % 50 == 0:
            print(f"Processing day {i}/{len(market_data)}")

        # Get historical data up to current day
        historical_data = market_data.iloc[:i+1]
        current_price = historical_data['close'].iloc[-1]

        # Get signals from all agents
        signals = [
            trading_system.fundamental_agent.analyze(historical_data, trading_system.portfolio),
            trading_system.technical_agent.analyze(historical_data, trading_system.portfolio),
            trading_system.sentiment_agent.analyze(historical_data, trading_system.portfolio),
            trading_system.risk_agent.analyze(historical_data, trading_system.portfolio)
        ]

        # Create state vector for RL
        state = trading_system.create_state_vector(historical_data, signals)

        # Get RL agent action
        rl_action = trading_system.rl_agent.act(state)
        action_map = {0: 'buy', 1: 'hold', 2: 'sell'}
        rl_recommendation = action_map[rl_action]

        # Aggregate signals
        action, confidence, reasoning = trading_system.aggregate_signals(signals)

        # Blend with RL recommendation
        if rl_recommendation == action:
            confidence = min(confidence * 1.1, 0.95)

        # Execute trade
        trade_result = trading_system.execute_trade(
            symbol, action, confidence, current_price, reasoning
        )

        if trade_result['executed']:
            trade_history.append(trade_result)

        # Update portfolio value
        trading_system.portfolio['total_value'] = trading_system.get_portfolio_value({symbol: current_price})
        trading_system.portfolio['peak_value'] = max(
            trading_system.portfolio['peak_value'],
            trading_system.portfolio['total_value']
        )

        # Calculate performance metrics
        returns = (trading_system.portfolio['total_value'] - trading_system.initial_capital) / trading_system.initial_capital

        performance_history.append({
            'date': historical_data.index[-1],
            'portfolio_value': trading_system.portfolio['total_value'],
            'returns': returns,
            'price': current_price,
            'cash': trading_system.portfolio['cash'],
            'position_value': trading_system.portfolio['total_position_value'],
            'action': action,
            'confidence': confidence,
            'signals': {s.agent_name: s.signal_type for s in signals}
        })

        # Train RL agent
        if i > 51:  # Need previous state
            prev_state = trading_system.create_state_vector(market_data.iloc[:i], signals)
            reward = (trading_system.portfolio['total_value'] - performance_history[-2]['portfolio_value']) / trading_system.initial_capital
            trading_system.rl_agent.remember(prev_state, rl_action, reward, state, False)

            if i % 10 == 0:  # Train every 10 steps
                trading_system.rl_agent.replay()

        # Update target network periodically
        if i % 100 == 0:
            trading_system.rl_agent.update_target_network()

    print("Backtest completed")
    return pd.DataFrame(performance_history), trade_history

def calculate_performance_metrics(performance_df: pd.DataFrame) -> Dict[str, float]:
    """Calculate comprehensive performance metrics"""

    # Basic metrics
    total_return = performance_df['returns'].iloc[-1]

    # Calculate daily returns
    portfolio_values = performance_df['portfolio_value'].values
    daily_returns = np.diff(portfolio_values) / portfolio_values[:-1]

    # Sharpe ratio
    if len(daily_returns) > 0 and daily_returns.std() > 0:
        sharpe_ratio = np.sqrt(252) * daily_returns.mean() / daily_returns.std()
    else:
        sharpe_ratio = 0

    # Maximum drawdown
    peak = np.maximum.accumulate(portfolio_values)
    drawdown = (peak - portfolio_values) / peak
    max_drawdown = np.max(drawdown)

    # Win rate
    winning_days = np.sum(daily_returns > 0)
    total_days = len(daily_returns)
    win_rate = winning_days / total_days if total_days > 0 else 0

    # Volatility
    annual_volatility = daily_returns.std() * np.sqrt(252) if len(daily_returns) > 0 else 0

    # Calculate Sortino ratio (downside deviation)
    negative_returns = daily_returns[daily_returns < 0]
    downside_deviation = negative_returns.std() * np.sqrt(252) if len(negative_returns) > 0 else 1
    sortino_ratio = (daily_returns.mean() * 252 - RISK_FREE_RATE) / downside_deviation if downside_deviation > 0 else 0

    # Calmar ratio
    calmar_ratio = (total_return * 252 / len(performance_df)) / max_drawdown if max_drawdown > 0 else 0

    return {
        'total_return': total_return,
        'annual_return': ((1 + total_return) ** (252 / len(performance_df)) - 1) if len(performance_df) > 0 else 0,
        'sharpe_ratio': sharpe_ratio,
        'sortino_ratio': sortino_ratio,
        'calmar_ratio': calmar_ratio,
        'max_drawdown': max_drawdown,
        'win_rate': win_rate,
        'annual_volatility': annual_volatility
    }

# Gradio Interface
def create_gradio_interface():
    """Create professional Gradio interface for the trading system"""

    def run_simulation(initial_capital, volatility, trading_days, openai_api_key, news_api_key):
        """Run comprehensive trading simulation"""

        print(f"Starting simulation with capital: ${initial_capital:,.2f}")

        # Initialize trading system with API keys
        trading_system = MultiAgentTradingSystem(
            initial_capital=float(initial_capital),
            openai_api_key=openai_api_key if openai_api_key else None,
            news_api_key=news_api_key if news_api_key else None
        )

        # Generate market data
        market_simulator = MarketSimulator(volatility=float(volatility))
        market_data = market_simulator.generate_market_data(int(trading_days))

        # Run backtest
        performance_df, trade_history = run_backtest(trading_system, market_data, "DEMO")

        # Calculate metrics
        metrics = calculate_performance_metrics(performance_df)

        # Create performance visualization
        fig = make_subplots(
            rows=4, cols=1,
            subplot_titles=(
                'Portfolio Value vs Market Price',
                'Portfolio Allocation',
                'Agent Signal Distribution',
                'Drawdown Analysis'
            ),
            vertical_spacing=0.08,
            row_heights=[0.35, 0.25, 0.20, 0.20]
        )

        # Portfolio value and market price
        fig.add_trace(
            go.Scatter(
                x=performance_df['date'],
                y=performance_df['portfolio_value'],
                name='Portfolio Value',
                line=dict(color='blue', width=2)
            ),
            row=1, col=1
        )

        # Normalize market price for comparison
        normalized_price = performance_df['price'] * initial_capital / performance_df['price'].iloc[0]
        fig.add_trace(
            go.Scatter(
                x=performance_df['date'],
                y=normalized_price,
                name='Buy & Hold',
                line=dict(color='gray', dash='dash')
            ),
            row=1, col=1
        )

        # Portfolio allocation
        fig.add_trace(
            go.Scatter(
                x=performance_df['date'],
                y=performance_df['cash'],
                name='Cash',
                fill='tonexty',
                stackgroup='one',
                line=dict(color='green')
            ),
            row=2, col=1
        )
        fig.add_trace(
            go.Scatter(
                x=performance_df['date'],
                y=performance_df['position_value'],
                name='Positions',
                fill='tonexty',
                stackgroup='one',
                line=dict(color='orange')
            ),
            row=2, col=1
        )

        # Agent signals analysis
        agent_signals = pd.DataFrame([p['signals'] for p in performance_df.to_dict('records')])
        signal_counts = {}
        for agent in ['Fundamental Analyst', 'Technical Analyst', 'Sentiment Analyst', 'Risk Manager']:
            if agent in agent_signals.columns:
                signal_counts[agent] = agent_signals[agent].value_counts().to_dict()

        # Create stacked bar chart for signals
        agents = list(signal_counts.keys())
        buy_counts = [signal_counts[agent].get('buy', 0) for agent in agents]
        hold_counts = [signal_counts[agent].get('hold', 0) for agent in agents]
        sell_counts = [signal_counts[agent].get('sell', 0) for agent in agents]

        fig.add_trace(
            go.Bar(name='Buy', x=agents, y=buy_counts, marker_color='green'),
            row=3, col=1
        )
        fig.add_trace(
            go.Bar(name='Hold', x=agents, y=hold_counts, marker_color='yellow'),
            row=3, col=1
        )
        fig.add_trace(
            go.Bar(name='Sell', x=agents, y=sell_counts, marker_color='red'),
            row=3, col=1
        )

        # Drawdown chart
        portfolio_values = performance_df['portfolio_value'].values
        peak = np.maximum.accumulate(portfolio_values)
        drawdown = (peak - portfolio_values) / peak * 100  # Convert to percentage

        fig.add_trace(
            go.Scatter(
                x=performance_df['date'],
                y=-drawdown,  # Negative for visual clarity
                fill='tozeroy',
                name='Drawdown %',
                line=dict(color='red')
            ),
            row=4, col=1
        )

        # Update layout
        fig.update_layout(
            height=1200,
            showlegend=True,
            title_text=f"Multi-Agent Trading System Performance Analysis",
            title_font_size=20
        )

        fig.update_xaxes(title_text="Date", row=4, col=1)
        fig.update_yaxes(title_text="Value ($)", row=1, col=1)
        fig.update_yaxes(title_text="Value ($)", row=2, col=1)
        fig.update_yaxes(title_text="Signal Count", row=3, col=1)
        fig.update_yaxes(title_text="Drawdown (%)", row=4, col=1)

        # Stack bars
        fig.update_layout(barmode='stack')

        # Create metrics summary
        metrics_text = f"""
        ## Performance Metrics

        **Returns**
        - Total Return: {metrics['total_return']*100:.2f}%
        - Annualized Return: {metrics['annual_return']*100:.2f}%

        **Risk Metrics**
        - Sharpe Ratio: {metrics['sharpe_ratio']:.2f}
        - Sortino Ratio: {metrics['sortino_ratio']:.2f}
        - Calmar Ratio: {metrics['calmar_ratio']:.2f}
        - Maximum Drawdown: {metrics['max_drawdown']*100:.2f}%
        - Annual Volatility: {metrics['annual_volatility']*100:.1f}%

        **Trading Statistics**
        - Win Rate: {metrics['win_rate']*100:.1f}%
        - Total Trades: {len(trade_history)}
        - Average Confidence: {performance_df['confidence'].mean():.2%}

        **Portfolio Summary**
        - Final Portfolio Value: ${performance_df['portfolio_value'].iloc[-1]:,.2f}
        - Final Cash Position: ${performance_df['cash'].iloc[-1]:,.2f}
        - Final Position Value: ${performance_df['position_value'].iloc[-1]:,.2f}
        """

        # Create trade history table
        if trade_history:
            # Get last 20 trades
            recent_trades = trade_history[-20:]
            trade_df = pd.DataFrame([
                {
                    'Date': t['timestamp'].strftime('%Y-%m-%d'),
                    'Action': t['action'].upper(),
                    'Shares': f"{t['shares']:+d}",
                    'Price': f"${t['price']:.2f}",
                    'Value': f"${abs(t['value']):,.2f}",
                    'Confidence': f"{t['confidence']:.1%}"
                }
                for t in recent_trades
            ])
        else:
            trade_df = pd.DataFrame()

        # Agent analysis for the last day
        if performance_df['signals'].iloc[-1]:
            last_signals = performance_df['signals'].iloc[-1]
            agent_summary = "## Latest Agent Consensus\n\n"

            for agent_name, signal in last_signals.items():
                agent_summary += f"**{agent_name}**: {signal.upper()}\n"

            agent_summary += f"\n**Final Decision**: {performance_df['action'].iloc[-1].upper()} "
            agent_summary += f"with {performance_df['confidence'].iloc[-1]:.1%} confidence"
        else:
            agent_summary = "## Agent Analysis\n\nNo signals available"

        return fig, metrics_text, trade_df, agent_summary

    # Create Gradio interface
    with gr.Blocks(title="LLM-Powered Multi-Agent Trading System", theme=gr.themes.Base()) as interface:
        gr.Markdown("""
        # LLM-Powered Multi-Agent Trading System

        This professional trading system demonstrates sophisticated multi-agent coordination for algorithmic trading:

        **Core Components:**
        - **Fundamental Analysis Agent**: Uses OpenAI LLM for real market analysis and trading insights
        - **Technical Analysis Agent**: Employs transformer neural networks for price pattern recognition
        - **Sentiment Analysis Agent**: Leverages FinBERT for financial sentiment analysis with real news data
        - **Risk Management Agent**: Monitors portfolio risk metrics and provides risk-adjusted recommendations
        - **DQN Coordinator**: Deep Q-Network that learns optimal trading strategies from agent signals

        **Key Features:**
        - Real LLM integration for genuine fundamental analysis reasoning
        - Advanced neural network models for pattern recognition
        - Comprehensive risk management framework with Kelly Criterion
        - Reinforcement learning for strategy optimization
        - Professional-grade backtesting and performance analytics

        Author: Spencer Purdy
        """)

        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### Simulation Parameters")
                initial_capital = gr.Number(
                    value=100000,
                    label="Initial Capital ($)",
                    minimum=10000,
                    maximum=1000000,
                    info="Starting capital for the simulation"
                )
                volatility = gr.Slider(
                    minimum=0.01,
                    maximum=0.05,
                    value=0.02,
                    step=0.005,
                    label="Market Volatility",
                    info="Annual volatility of the simulated market"
                )
                trading_days = gr.Slider(
                    minimum=100,
                    maximum=500,
                    value=252,
                    step=10,
                    label="Trading Days",
                    info="Number of trading days to simulate"
                )

                gr.Markdown("### API Keys (Optional)")
                openai_api_key = gr.Textbox(
                    label="OpenAI API Key",
                    placeholder="sk-...",
                    type="password",
                    info="For real LLM fundamental analysis (leave empty for fallback)"
                )
                news_api_key = gr.Textbox(
                    label="News API Key",
                    placeholder="Your NewsAPI key",
                    type="password",
                    info="For real news sentiment analysis (leave empty for contextual news)"
                )

                run_button = gr.Button("Run Simulation", variant="primary", size="lg")

        with gr.Row():
            with gr.Column(scale=3):
                performance_plot = gr.Plot(label="Performance Analysis Dashboard")

            with gr.Column(scale=1):
                metrics_display = gr.Markdown(label="Performance Metrics")

        with gr.Row():
            with gr.Column():
                trade_table = gr.DataFrame(
                    label="Recent Trading Activity (Last 20 Trades)",
                    headers=["Date", "Action", "Shares", "Price", "Value", "Confidence"]
                )

        with gr.Row():
            with gr.Column():
                agent_display = gr.Markdown(label="Agent Analysis")

        # Connect interface
        run_button.click(
            fn=run_simulation,
            inputs=[initial_capital, volatility, trading_days, openai_api_key, news_api_key],
            outputs=[performance_plot, metrics_display, trade_table, agent_display]
        )

        # Add professional examples
        gr.Examples(
            examples=[
                [100000, 0.02, 252, "", ""],  # Standard market conditions
                [50000, 0.03, 365, "", ""],   # Higher volatility environment
                [200000, 0.015, 180, "", ""], # Lower volatility environment
            ],
            inputs=[initial_capital, volatility, trading_days, openai_api_key, news_api_key],
            label="Example Configurations"
        )

        gr.Markdown("""
        ---
        **Note**: This system uses sophisticated machine learning models including real LLM integration for fundamental analysis.
        For best results, provide an OpenAI API key for genuine LLM reasoning and a News API key for real news sentiment analysis.
        The simulation may take a few moments to initialize and run. All trading decisions are for demonstration
        purposes only and should not be used for actual trading without proper validation and risk assessment.

        **API Key Information**:
        - OpenAI API Key: Get yours at https://platform.openai.com/api-keys
        - News API Key: Get yours at https://newsapi.org/register
        """)

    return interface

# Launch the application
if __name__ == "__main__":
    interface = create_gradio_interface()
    interface.launch()