Pairs Trading Strategy with Ollama: Complete Guide to Statistical Arbitrage and Correlation Analysis

# Correlation vs Cointegration Example
import numpy as np
import pandas as pd
from statsmodels.tsa.stattools import coint

# Calculate correlation coefficient
correlation = stock_a.corr(stock_b)
print(f"Correlation: {correlation:.3f}")

# Test for cointegration
coint_score, p_value, critical_values = coint(stock_a, stock_b)
print(f"Cointegration p-value: {p_value:.3f}")

# Determine if pair is suitable for trading
if p_value < 0.05 and correlation > 0.7:
    print("Pair shows strong statistical relationship")

# Download and install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Verify installation
ollama --version

# Install models for financial analysis
ollama pull llama3.1:8b
ollama pull codellama:13b

# Verify model availability  
ollama list

import ollama
import yfinance as yf
import pandas as pd
import numpy as np

# Initialize Ollama client
client = ollama.Client()

# Test connection
response = client.chat(model='llama3.1:8b', messages=[
    {'role': 'user', 'content': 'Calculate correlation between two price series'}
])
print(response['message']['content'])

class PairsTradingDataPipeline:
    def __init__(self, symbols, period='1y'):
        self.symbols = symbols
        self.period = period
        self.data = {}
    
    def fetch_market_data(self):
        """Download price data for symbol pairs"""
        for symbol in self.symbols:
            ticker = yf.Ticker(symbol)
            # Get adjusted closing prices
            self.data[symbol] = ticker.history(period=self.period)['Close']
        
        return pd.DataFrame(self.data)
    
    def calculate_returns(self, data):
        """Compute daily returns for correlation analysis"""
        returns = data.pct_change().dropna()
        return returns
    
    def prepare_ollama_input(self, data):
        """Format data for Ollama analysis"""
        summary_stats = data.describe()
        correlation_matrix = data.corr()
        
        # Create structured prompt for Ollama
        prompt = f"""
        Analyze this pairs trading opportunity:
        
        Summary Statistics:
        {summary_stats.to_string()}
        
        Correlation Matrix:
        {correlation_matrix.to_string()}
        
        Identify the strongest correlated pairs and assess their trading potential.
        """
        
        return prompt

# Example usage
pipeline = PairsTradingDataPipeline(['AAPL', 'MSFT', 'GOOGL', 'META'])
market_data = pipeline.fetch_market_data()
analysis_prompt = pipeline.prepare_ollama_input(market_data)

def advanced_correlation_analysis(symbols, data):
    """Comprehensive correlation analysis using Ollama"""
    
    # Calculate multiple correlation types
    pearson_corr = data.corr(method='pearson')
    spearman_corr = data.corr(method='spearman')
    
    # Rolling correlation analysis
    window = 30  # 30-day rolling window
    rolling_corr = data.rolling(window=window).corr()
    
    # Prepare comprehensive analysis prompt
    analysis_prompt = f"""
    Perform pairs trading correlation analysis:
    
    Static Correlations:
    Pearson: {pearson_corr.to_string()}
    Spearman: {spearman_corr.to_string()}
    
    Recent Rolling Correlation (30-day):
    {rolling_corr.tail().to_string()}
    
    Instructions:
    1. Identify pairs with correlation > 0.7
    2. Check for correlation stability over time
    3. Flag pairs showing recent correlation breakdown
    4. Recommend top 3 pairs for trading
    5. Suggest optimal hedge ratios for each pair
    """
    
    # Query Ollama for analysis
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': analysis_prompt}
    ])
    
    return response['message']['content']

# Execute correlation analysis
correlation_results = advanced_correlation_analysis(['AAPL', 'MSFT'], market_data)
print(correlation_results)

class CorrelationMonitor:
    def __init__(self, pairs, threshold=0.05):
        self.pairs = pairs
        self.threshold = threshold  # Correlation change threshold
        self.historical_corr = {}
    
    def update_correlations(self, current_data):
        """Update correlation tracking"""
        current_corr = current_data.corr()
        
        for pair in self.pairs:
            symbol_a, symbol_b = pair
            current_value = current_corr.loc[symbol_a, symbol_b]
            
            # Check for significant changes
            if pair in self.historical_corr:
                prev_value = self.historical_corr[pair]
                change = abs(current_value - prev_value)
                
                if change > self.threshold:
                    self.send_correlation_alert(pair, prev_value, current_value)
            
            self.historical_corr[pair] = current_value
    
    def send_correlation_alert(self, pair, old_corr, new_corr):
        """Generate Ollama-powered correlation alerts"""
        alert_prompt = f"""
        Correlation change detected for pair {pair[0]}/{pair[1]}:
        Previous correlation: {old_corr:.3f}
        Current correlation: {new_corr:.3f}
        Change magnitude: {abs(new_corr - old_corr):.3f}
        
        Analyze this correlation change:
        1. Is this a temporary fluctuation or structural shift?
        2. Should we adjust position sizing?
        3. Does this affect the pair's trading viability?
        4. Recommend specific actions (hold, reduce, exit)
        """
        
        response = client.chat(model='llama3.1:8b', messages=[
            {'role': 'user', 'content': alert_prompt}
        ])
        
        print(f"Correlation Alert: {response['message']['content']}")

# Initialize monitoring system
monitor = CorrelationMonitor([('AAPL', 'MSFT'), ('GOOGL', 'META')])

def generate_zscore_signals(pair_data, lookback=60):
    """Generate trading signals using Z-score analysis"""
    
    # Calculate price spread
    stock_a, stock_b = pair_data.columns
    spread = pair_data[stock_a] - pair_data[stock_b]
    
    # Calculate rolling Z-score
    rolling_mean = spread.rolling(window=lookback).mean()
    rolling_std = spread.rolling(window=lookback).std()
    zscore = (spread - rolling_mean) / rolling_std
    
    # Generate signals
    signals = pd.DataFrame(index=pair_data.index)
    signals['spread'] = spread
    signals['zscore'] = zscore
    signals['position'] = 0
    
    # Entry signals
    signals.loc[zscore > 2, 'position'] = -1  # Short spread
    signals.loc[zscore < -2, 'position'] = 1   # Long spread
    
    # Exit signals  
    signals.loc[abs(zscore) < 0.5, 'position'] = 0
    
    return signals

# Example signal generation
pair_signals = generate_zscore_signals(market_data[['AAPL', 'MSFT']])

def validate_signals_with_ollama(signals, market_context):
    """Use Ollama to validate statistical trading signals"""
    
    recent_signals = signals.tail(10)
    
    validation_prompt = f"""
    Validate these pairs trading signals:
    
    Recent Signals:
    {recent_signals.to_string()}
    
    Market Context:
    - VIX Level: {market_context.get('vix', 'N/A')}
    - Market Trend: {market_context.get('trend', 'N/A')}
    - Economic Events: {market_context.get('events', 'None scheduled')}
    
    Analysis Requirements:
    1. Are current signals consistent with market conditions?
    2. Should position sizing be adjusted for volatility?
    3. Are there any fundamental risks to ignore signals?
    4. Rate signal confidence from 1-10
    5. Suggest any timing adjustments
    
    Provide actionable recommendations for each signal.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': validation_prompt}
    ])
    
    return response['message']['content']

# Validate signals with market context
market_context = {
    'vix': 18.5,
    'trend': 'neutral',
    'events': 'Fed meeting next week'
}

validation_results = validate_signals_with_ollama(pair_signals, market_context)
print(validation_results)

def calculate_dynamic_position_size(correlation, volatility, max_risk=0.02):
    """Calculate position size based on correlation and volatility"""
    
    # Base position size on correlation strength
    correlation_factor = min(correlation / 0.8, 1.0)  # Scale for 0.8+ correlation
    
    # Adjust for volatility
    volatility_factor = min(0.15 / volatility, 1.0)  # Scale for 15% volatility
    
    # Calculate final position size
    position_size = max_risk * correlation_factor * volatility_factor
    
    sizing_prompt = f"""
    Position sizing analysis:
    - Correlation: {correlation:.3f}
    - Volatility: {volatility:.3f}
    - Calculated size: {position_size:.3f}
    - Max risk: {max_risk:.3f}
    
    Validate this position sizing:
    1. Is the size appropriate for current market conditions?
    2. Should we apply additional risk adjustments?
    3. Are there correlation-specific considerations?
    4. Recommend final position size as percentage of portfolio
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': sizing_prompt}
    ])
    
    return position_size, response['message']['content']

# Example position sizing
correlation = 0.75
volatility = 0.20
size, analysis = calculate_dynamic_position_size(correlation, volatility)
print(f"Recommended position size: {size:.3f}")
print(f"Ollama analysis: {analysis}")

def optimize_exit_levels(spread_data, entry_zscore):
    """Optimize stop-loss and take-profit levels using Ollama"""
    
    # Calculate historical spread statistics
    spread_stats = spread_data.describe()
    spread_volatility = spread_data.std()
    
    # Analyze spread reversion patterns
    optimization_prompt = f"""
    Optimize exit levels for pairs trade:
    
    Entry Z-score: {entry_zscore:.2f}
    Spread Statistics:
    {spread_stats.to_string()}
    
    Historical Analysis:
    - Spread volatility: {spread_volatility:.4f}
    - 95th percentile: {spread_data.quantile(0.95):.4f}
    - 5th percentile: {spread_data.quantile(0.05):.4f}
    
    Optimization Goals:
    1. Calculate optimal take-profit Z-score level
    2. Determine appropriate stop-loss Z-score level  
    3. Consider time-based exits for stale positions
    4. Account for transaction costs in exit timing
    5. Suggest position scaling approach
    
    Provide specific Z-score levels and rationale.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': optimization_prompt}
    ])
    
    return response['message']['content']

# Optimize exits for current trade
spread_data = pair_signals['spread']
exit_optimization = optimize_exit_levels(spread_data, entry_zscore=2.1)
print(exit_optimization)

class PairsTradingBacktester:
    def __init__(self, start_date, end_date, initial_capital=100000):
        self.start_date = start_date
        self.end_date = end_date
        self.initial_capital = initial_capital
        self.trades = []
        self.portfolio_value = []
    
    def run_backtest(self, pair_data, signals):
        """Execute comprehensive backtest"""
        
        portfolio_value = self.initial_capital
        position = 0
        entry_price = 0
        
        for date, row in signals.iterrows():
            current_spread = row['spread']
            signal = row['position']
            
            # Handle position changes
            if position == 0 and signal != 0:
                # Enter new position
                position = signal
                entry_price = current_spread
                entry_date = date
                
            elif position != 0 and signal == 0:
                # Exit position
                exit_price = current_spread
                pnl = position * (exit_price - entry_price)
                portfolio_value += pnl
                
                # Record trade
                trade = {
                    'entry_date': entry_date,
                    'exit_date': date,
                    'entry_price': entry_price,
                    'exit_price': exit_price,
                    'position': position,
                    'pnl': pnl,
                    'portfolio_value': portfolio_value
                }
                self.trades.append(trade)
                
                position = 0
            
            self.portfolio_value.append(portfolio_value)
        
        return self.analyze_performance()
    
    def analyze_performance(self):
        """Generate comprehensive performance analysis"""
        
        trades_df = pd.DataFrame(self.trades)
        
        if len(trades_df) == 0:
            return "No trades executed during backtest period"
        
        # Calculate performance metrics
        total_return = (self.portfolio_value[-1] / self.initial_capital - 1) * 100
        winning_trades = len(trades_df[trades_df['pnl'] > 0])
        total_trades = len(trades_df)
        win_rate = (winning_trades / total_trades) * 100 if total_trades > 0 else 0
        
        avg_win = trades_df[trades_df['pnl'] > 0]['pnl'].mean()
        avg_loss = trades_df[trades_df['pnl'] < 0]['pnl'].mean()
        
        performance_prompt = f"""
        Analyze pairs trading backtest results:
        
        Performance Summary:
        - Total Return: {total_return:.2f}%
        - Total Trades: {total_trades}
        - Win Rate: {win_rate:.1f}%
        - Average Win: ${avg_win:.2f}
        - Average Loss: ${avg_loss:.2f}
        - Profit Factor: {avg_win / abs(avg_loss) if avg_loss != 0 else 'N/A'}
        
        Trade Details:
        {trades_df.head(10).to_string()}
        
        Analysis Requirements:
        1. Assess overall strategy performance
        2. Identify strengths and weaknesses
        3. Suggest parameter optimizations
        4. Recommend risk management improvements
        5. Compare to buy-and-hold benchmark
        6. Provide actionable next steps
        
        Focus on practical improvements for live trading.
        """
        
        response = client.chat(model='llama3.1:8b', messages=[
            {'role': 'user', 'content': performance_prompt}
        ])
        
        return {
            'metrics': {
                'total_return': total_return,
                'win_rate': win_rate,
                'total_trades': total_trades,
                'avg_win': avg_win,
                'avg_loss': avg_loss
            },
            'ollama_analysis': response['message']['content'],
            'trades': trades_df
        }

# Run backtest example
backtester = PairsTradingBacktester('2023-01-01', '2024-01-01')
backtest_results = backtester.run_backtest(market_data[['AAPL', 'MSFT']], pair_signals)
print(backtest_results['ollama_analysis'])

def setup_forward_testing(pairs, test_duration_days=30):
    """Setup forward testing environment with Ollama monitoring"""
    
    forward_test_prompt = f"""
    Design forward testing protocol for pairs trading:
    
    Test Parameters:
    - Pairs: {pairs}
    - Duration: {test_duration_days} days
    - Test start: Today
    
    Protocol Requirements:
    1. Define success metrics for forward test
    2. Set monitoring intervals for performance review
    3. Establish criteria for stopping unsuccessful tests
    4. Create reporting format for daily updates
    5. Design contingency plans for unexpected market events
    
    Provide detailed testing framework with checkpoints.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': forward_test_prompt}
    ])
    
    return response['message']['content']

# Setup forward testing
forward_test_plan = setup_forward_testing([('AAPL', 'MSFT'), ('GOOGL', 'META')])
print(forward_test_plan)

from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler

def ml_enhanced_pairs_trading(market_data, features_lookback=20):
    """Integrate machine learning with Ollama for enhanced predictions"""
    
    # Prepare feature matrix
    features = []
    target = []
    
    for i in range(features_lookback, len(market_data)):
        # Create feature vector from historical data
        feature_window = market_data.iloc[i-features_lookback:i]
        
        # Calculate technical indicators as features
        price_ratio = feature_window.iloc[:, 0] / feature_window.iloc[:, 1]
        price_ratio_ma = price_ratio.rolling(5).mean().iloc[-1]
        price_ratio_std = price_ratio.rolling(5).std().iloc[-1]
        
        feature_vector = [
            price_ratio.iloc[-1],
            price_ratio_ma,
            price_ratio_std,
            feature_window.iloc[:, 0].pct_change().iloc[-1],
            feature_window.iloc[:, 1].pct_change().iloc[-1]
        ]
        
        features.append(feature_vector)
        
        # Target: next period price ratio change
        if i < len(market_data) - 1:
            next_ratio = market_data.iloc[i+1, 0] / market_data.iloc[i+1, 1]
            current_ratio = market_data.iloc[i, 0] / market_data.iloc[i, 1]
            target.append(next_ratio - current_ratio)
    
    # Train ML model
    X = np.array(features[:-1])  # Remove last feature (no target)
    y = np.array(target)
    
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X)
    
    model = RandomForestRegressor(n_estimators=100, random_state=42)
    model.fit(X_scaled, y)
    
    # Generate ML prediction
    latest_features = np.array([features[-1]]).reshape(1, -1)
    latest_features_scaled = scaler.transform(latest_features)
    ml_prediction = model.predict(latest_features_scaled)[0]
    
    # Get Ollama interpretation
    ml_interpretation_prompt = f"""
    Interpret machine learning prediction for pairs trading:
    
    ML Model Output:
    - Predicted price ratio change: {ml_prediction:.4f}
    - Model type: Random Forest Regression
    - Feature importance: Price ratio (current), MA(5), Std(5), Returns
    
    Current Market State:
    - Current price ratio: {features[-1][0]:.4f}
    - 5-day MA ratio: {features[-1][1]:.4f}
    - 5-day volatility: {features[-1][2]:.4f}
    
    Interpretation Tasks:
    1. Translate ML prediction into trading signal strength
    2. Assess prediction confidence based on current features
    3. Recommend position sizing based on prediction magnitude
    4. Identify any warning signs in the feature pattern
    5. Provide plain-English explanation of the prediction
    
    Focus on actionable trading insights.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': ml_interpretation_prompt}
    ])
    
    return {
        'ml_prediction': ml_prediction,
        'features': features[-1],
        'ollama_interpretation': response['message']['content']
    }

# Example ML integration
ml_results = ml_enhanced_pairs_trading(market_data[['AAPL', 'MSFT']])
print(ml_results['ollama_interpretation'])

def multi_timeframe_analysis(symbol_pair, timeframes=['1d', '1h', '15m']):
    """Perform multi-timeframe pairs analysis with Ollama synthesis"""
    
    timeframe_data = {}
    
    # Collect data for each timeframe
    for tf in timeframes:
        # In practice, you'd fetch different interval data
        # This is a simplified example
        if tf == '1d':
            tf_data = yf.download(symbol_pair, period='1y', interval='1d')
        elif tf == '1h':
            tf_data = yf.download(symbol_pair, period='60d', interval='1h')
        else:  # 15m
            tf_data = yf.download(symbol_pair, period='30d', interval='15m')
        
        # Calculate correlation and spread for timeframe
        correlation = tf_data['Close'].corr().iloc[0, 1]
        spread = tf_data['Close'].iloc[:, 0] - tf_data['Close'].iloc[:, 1]
        zscore = (spread - spread.mean()) / spread.std()
        
        timeframe_data[tf] = {
            'correlation': correlation,
            'current_zscore': zscore.iloc[-1],
            'zscore_trend': zscore.tail(5).mean(),
            'data_points': len(tf_data)
        }
    
    # Ollama multi-timeframe synthesis
    synthesis_prompt = f"""
    Synthesize multi-timeframe pairs trading analysis:
    
    Timeframe Analysis:
    Daily: Correlation={timeframe_data['1d']['correlation']:.3f}, Z-score={timeframe_data['1d']['current_zscore']:.2f}
    Hourly: Correlation={timeframe_data['1h']['correlation']:.3f}, Z-score={timeframe_data['1h']['current_zscore']:.2f}
    15-min: Correlation={timeframe_data['15m']['correlation']:.3f}, Z-score={timeframe_data['15m']['current_zscore']:.2f}
    
    Z-score Trends (5-period average):
    Daily: {timeframe_data['1d']['zscore_trend']:.2f}
    Hourly: {timeframe_data['1h']['zscore_trend']:.2f}
    15-min: {timeframe_data['15m']['zscore_trend']:.2f}
    
    Multi-Timeframe Strategy Requirements:
    1. Determine dominant timeframe signal
    2. Identify conflicting signals and resolution approach
    3. Suggest optimal entry timing across timeframes
    4. Recommend timeframe for position monitoring
    5. Design multi-timeframe exit strategy
    6. Assess overall signal strength (1-10 scale)
    
    Provide specific timing recommendations for trade execution.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': synthesis_prompt}
    ])
    
    return {
        'timeframe_data': timeframe_data,
        'synthesis': response['message']['content']
    }

# Execute multi-timeframe analysis
mtf_analysis = multi_timeframe_analysis(['AAPL', 'MSFT'])
print(mtf_analysis['synthesis'])

import asyncio
import websocket
import json
from datetime import datetime

class ProductionPairsTrader:
    def __init__(self, api_key, secret_key, ollama_model='llama3.1:8b'):
        self.api_key = api_key
        self.secret_key = secret_key
        self.ollama_model = ollama_model
        self.active_positions = {}
        self.monitoring_pairs = []
        
    async def start_trading_system(self):
        """Start the production trading system"""
        
        startup_prompt = f"""
        Production pairs trading system startup checklist:
        
        System Components:
        - Real-time data feed: WebSocket connections
        - Order management: REST API integration  
        - Risk management: Position limits and stops
        - Monitoring: Ollama-powered alerts
        - Logging: Trade and system event logs
        
        Startup Verification:
        1. Confirm all API connections are active
        2. Verify account permissions and balances
        3. Test order placement with small quantities
        4. Initialize monitoring for target pairs
        5. Setup emergency shutdown procedures
        6. Activate real-time risk monitoring
        
        Provide startup sequence and safety checks.
        """
        
        response = client.chat(model=self.ollama_model, messages=[
            {'role': 'user', 'content': startup_prompt}
        ])
        
        print("System Startup Guidance:")
        print(response['message']['content'])
        
        # Initialize system components
        await self.setup_data_feeds()
        await self.initialize_risk_management()
        await self.start_monitoring_loop()
    
    async def setup_data_feeds(self):
        """Setup real-time market data connections"""
        print("Connecting to real-time data feeds...")
        # WebSocket connection setup would go here
        
    async def initialize_risk_management(self):
        """Initialize risk management systems"""
        print("Initializing risk management protocols...")
        
    async def start_monitoring_loop(self):
        """Start the main trading monitoring loop"""
        while True:
            try:
                # Monitor active positions
                await self.check_active_positions()
                
                # Scan for new opportunities
                await self.scan_trading_opportunities()
                
                # Update risk metrics
                await self.update_risk_metrics()
                
                # Wait before next iteration
                await asyncio.sleep(60)  # Check every minute
                
            except Exception as e:
                print(f"Error in monitoring loop: {e}")
                await asyncio.sleep(10)  # Brief pause before retry
    
    async def check_active_positions(self):
        """Monitor existing positions with Ollama analysis"""
        
        for pair_id, position in self.active_positions.items():
            # Get current market data
            current_spread = await self.get_current_spread(position['symbols'])
            current_zscore = self.calculate_zscore(current_spread, position['spread_history'])
            
            # Ollama position analysis
            position_prompt = f"""
            Analyze active pairs trading position:
            
            Position Details:
            - Pair: {position['symbols']}
            - Entry Z-score: {position['entry_zscore']:.2f}
            - Current Z-score: {current_zscore:.2f}
            - Position size: {position['size']}
            - P&L: {position['current_pnl']:.2f}
            - Days held: {position['days_held']}
            
            Position Management:
            1. Should we maintain current position?
            2. Is partial profit-taking appropriate?
            3. Should we adjust stop-loss levels?
            4. Are there any emerging risks?
            5. Recommend specific actions
            
            Provide immediate actionable recommendations.
            """
            
            response = client.chat(model=self.ollama_model, messages=[
                {'role': 'user', 'content': position_prompt}
            ])
            
            # Process Ollama recommendations
            await self.process_position_recommendations(
                pair_id, 
                response['message']['content']
            )
    
    async def process_position_recommendations(self, pair_id, recommendations):
        """Process and execute Ollama position recommendations"""
        
        # In production, parse recommendations and execute trades
        print(f"Position {pair_id} recommendations: {recommendations}")
        
        # Example: Check for exit signals in recommendations
        if "exit" in recommendations.lower() or "close" in recommendations.lower():
            await self.close_position(pair_id)
        elif "reduce" in recommendations.lower():
            await self.reduce_position(pair_id, 0.5)  # Reduce by 50%

# Production system initialization
# trader = ProductionPairsTrader(api_key="your_key", secret_key="your_secret")
# asyncio.run(trader.start_trading_system())

class PairsTradingMonitor:
    def __init__(self, notification_channels=['email', 'slack']):
        self.notification_channels = notification_channels
        self.alert_history = []
    
    def generate_daily_report(self, trading_data):
        """Generate comprehensive daily performance report"""
        
        report_prompt = f"""
        Generate daily pairs trading performance report:
        
        Trading Summary:
        - Active positions: {len(trading_data.get('positions', []))}
        - Trades executed: {trading_data.get('trades_today', 0)}
        - Daily P&L: ${trading_data.get('daily_pnl', 0):.2f}
        - Weekly P&L: ${trading_data.get('weekly_pnl', 0):.2f}
        - Monthly P&L: ${trading_data.get('monthly_pnl', 0):.2f}
        
        Risk Metrics:
        - Max drawdown: {trading_data.get('max_drawdown', 0):.2f}%
        - Portfolio exposure: {trading_data.get('exposure', 0):.2f}%
        - Average correlation: {trading_data.get('avg_correlation', 0):.3f}
        
        Report Requirements:
        1. Summarize trading performance highlights
        2. Identify any concerning patterns or risks
        3. Recommend adjustments for tomorrow's trading
        4. Flag pairs requiring attention
        5. Assess overall strategy health
        6. Provide 3 key action items
        
        Format as executive summary for management review.
        """
        
        response = client.chat(model='llama3.1:8b', messages=[
            {'role': 'user', 'content': report_prompt}
        ])
        
        return response['message']['content']
    
    def setup_automated_alerts(self):
        """Configure automated alert system"""
        
        alert_config_prompt = """
        Design automated alert system for pairs trading:
        
        Alert Categories:
        1. Position alerts (large moves, stop-loss hits)
        2. Correlation alerts (breakdown, strengthening)
        3. System alerts (connection issues, errors)
        4. Risk alerts (exposure limits, drawdown)
        5. Opportunity alerts (new high-confidence setups)
        
        Alert Configuration:
        - Specify trigger conditions for each alert type
        - Define urgency levels (low, medium, high, critical)
        - Recommend notification timing and frequency
        - Design message templates for each alert type
        - Setup escalation procedures for critical alerts
        
        Provide comprehensive alert framework.
        """
        
        response = client.chat(model='llama3.1:8b', messages=[
            {'role': 'user', 'content': alert_config_prompt}
        ])
        
        return response['message']['content']

# Initialize monitoring system
monitor = PairsTradingMonitor()
alert_framework = monitor.setup_automated_alerts()
print(alert_framework)

import concurrent.futures
import multiprocessing as mp

def optimize_pairs_processing(symbol_universe, max_workers=None):
    """Optimize pairs analysis for large symbol universes"""
    
    if max_workers is None:
        max_workers = mp.cpu_count()
    
    optimization_prompt = f"""
    Optimize pairs trading system for large-scale processing:
    
    System Requirements:
    - Symbol universe: {len(symbol_universe)} symbols
    - Potential pairs: {len(symbol_universe) * (len(symbol_universe) - 1) // 2}
    - Available CPU cores: {mp.cpu_count()}
    - Recommended workers: {max_workers}
    
    Optimization Strategy:
    1. Design efficient pair filtering to reduce processing load
    2. Implement parallel processing for correlation calculations
    3. Setup caching strategy for repeated calculations
    4. Optimize data structures for memory efficiency
    5. Design load balancing for uneven processing times
    6. Create monitoring for processing bottlenecks
    
    Provide specific implementation recommendations.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': optimization_prompt}
    ])
    
    return response['message']['content']

def parallel_correlation_analysis(symbol_pairs, market_data):
    """Process correlation analysis in parallel"""
    
    def analyze_single_pair(pair):
        symbol_a, symbol_b = pair
        pair_data = market_data[[symbol_a, symbol_b]].dropna()
        
        if len(pair_data) < 30:  # Minimum data requirement
            return None
        
        correlation = pair_data.corr().iloc[0, 1]
        
        # Quick filtering for promising pairs
        if correlation > 0.7:
            # Perform detailed analysis
            spread = pair_data.iloc[:, 0] - pair_data.iloc[:, 1]
            zscore = (spread - spread.mean()) / spread.std()
            
            return {
                'pair': pair,
                'correlation': correlation,
                'current_zscore': zscore.iloc[-1],
                'zscore_std': zscore.std(),
                'data_quality': len(pair_data)
            }
        
        return None
    
    # Process pairs in parallel
    with concurrent.futures.ProcessPoolExecutor(max_workers=max_workers) as executor:
        results = list(executor.map(analyze_single_pair, symbol_pairs))
    
    # Filter out None results
    valid_results = [r for r in results if r is not None]
    
    return valid_results

# Example optimization for large universe
symbol_universe = ['AAPL', 'MSFT', 'GOOGL', 'META', 'TSLA', 'NVDA', 'AMZN', 'NFLX']
optimization_guide = optimize_pairs_processing(symbol_universe)
print(optimization_guide)

def diagnose_correlation_breakdown(pair_symbols, historical_data, current_data):
    """Diagnose and respond to correlation breakdown"""
    
    # Calculate historical vs current correlations
    historical_corr = historical_data.corr().iloc[0, 1]
    current_corr = current_data.tail(30).corr().iloc[0, 1]
    correlation_change = current_corr - historical_corr
    
    # Analyze potential causes
    diagnosis_prompt = f"""
    Diagnose correlation breakdown in pairs trading:
    
    Correlation Analysis:
    - Historical correlation (1 year): {historical_corr:.3f}
    - Recent correlation (30 days): {current_corr:.3f}
    - Correlation change: {correlation_change:.3f}
    - Pair: {pair_symbols[0]}/{pair_symbols[1]}
    
    Diagnostic Questions:
    1. What are likely causes of this correlation breakdown?
    2. Is this temporary market stress or structural change?
    3. Should we immediately exit positions or wait?
    4. How can we detect similar breakdowns earlier?
    5. What risk management adjustments are needed?
    6. Should we remove this pair from trading universe?
    
    Additional Analysis:
    - Check for recent news affecting either stock
    - Examine sector rotation patterns
    - Review fundamental changes in business models
    - Assess broader market regime changes
    
    Provide actionable recommendations with specific steps.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': diagnosis_prompt}
    ])
    
    return response['message']['content']

# Example correlation breakdown diagnosis
breakdown_analysis = diagnose_correlation_breakdown(
    ['AAPL', 'MSFT'], 
    market_data, 
    market_data.tail(60)
)
print(breakdown_analysis)

def detect_market_regime_change(market_indicators):
    """Detect market regime changes affecting pairs trading"""
    
    regime_analysis_prompt = f"""
    Analyze market regime changes for pairs trading:
    
    Market Indicators:
    - VIX level: {market_indicators.get('vix', 'N/A')}
    - VIX change (30-day): {market_indicators.get('vix_change', 'N/A')}
    - Market correlation: {market_indicators.get('market_correlation', 'N/A')}
    - Sector rotation strength: {market_indicators.get('sector_rotation', 'N/A')}
    - Interest rate environment: {market_indicators.get('interest_rates', 'N/A')}
    
    Regime Assessment:
    1. Identify current market regime (bull, bear, transitional)
    2. Assess regime stability and likely duration
    3. Evaluate impact on pairs trading effectiveness
    4. Recommend strategy adjustments for current regime
    5. Design early warning system for regime changes
    6. Suggest defensive measures during regime transitions
    
    Focus on practical adjustments to maintain profitability.
    """
    
    response = client.chat(model='llama3.1:8b', messages=[
        {'role': 'user', 'content': regime_analysis_prompt}
    ])
    
    return response['message']['content']

# Market regime analysis
market_indicators = {
    'vix': 22.5,
    'vix_change': +4.2,
    'market_correlation': 0.65,
    'sector_rotation': 'high',
    'interest_rates': 'rising'
}

regime_analysis = detect_market_regime_change(market_indicators)
print(regime_analysis)