How to Analyze Stablecoin Depeg Risk with Ollama: USDT, USDC, DAI Monitor

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

# Download analysis-optimized models
ollama pull llama2:13b
ollama pull codellama:13b
ollama pull mistral:7b

# Verify installation
ollama list

# requirements.txt
requests==2.31.0
pandas==2.1.0
numpy==1.24.3
websocket-client==1.6.1
ollama==0.1.7
plotly==5.15.0
schedule==1.2.0

# Install dependencies
pip install -r requirements.txt

import ollama
import json

def test_ollama_connection():
    """Test Ollama API connection and model availability"""
    try:
        response = ollama.chat(
            model='llama2:13b',
            messages=[{
                'role': 'user',
                'content': 'Analyze this sample: USDT trading at $0.998. Is this concerning?'
            }]
        )
        print("✅ Ollama connected successfully")
        print(f"Response: {response['message']['content']}")
        return True
    except Exception as e:
        print(f"❌ Connection failed: {e}")
        return False

# Run connection test
test_ollama_connection()

import requests
import time
from datetime import datetime
import pandas as pd

class StablecoinDataCollector:
    def __init__(self):
        self.exchanges = {
            'binance': 'https://api.binance.com/api/v3/ticker/24hr',
            'coinbase': 'https://api.exchange.coinbase.com/products',
            'kraken': 'https://api.kraken.com/0/public/Ticker'
        }
        self.stablecoins = ['USDT', 'USDC', 'DAI']
        
    def get_binance_prices(self):
        """Fetch stablecoin prices from Binance"""
        try:
            response = requests.get(self.exchanges['binance'])
            data = response.json()
            
            prices = {}
            for item in data:
                symbol = item['symbol']
                if any(stable in symbol for stable in self.stablecoins):
                    if symbol.endswith('USDT') and symbol != 'USDTUSDT':
                        continue
                    prices[symbol] = {
                        'price': float(item['lastPrice']),
                        'volume': float(item['volume']),
                        'change_24h': float(item['priceChangePercent']),
                        'timestamp': datetime.now().isoformat()
                    }
            return prices
        except Exception as e:
            print(f"Binance API error: {e}")
            return {}
    
    def get_coinbase_prices(self):
        """Fetch stablecoin prices from Coinbase Pro"""
        prices = {}
        stablecoin_pairs = ['USDC-USD', 'DAI-USD']
        
        for pair in stablecoin_pairs:
            try:
                url = f"{self.exchanges['coinbase']}/{pair}/ticker"
                response = requests.get(url)
                data = response.json()
                
                prices[pair] = {
                    'price': float(data['price']),
                    'volume': float(data['volume']),
                    'timestamp': datetime.now().isoformat()
                }
            except Exception as e:
                print(f"Coinbase API error for {pair}: {e}")
                
        return prices
    
    def collect_all_data(self):
        """Aggregate data from all exchanges"""
        binance_data = self.get_binance_prices()
        coinbase_data = self.get_coinbase_prices()
        
        combined_data = {
            'binance': binance_data,
            'coinbase': coinbase_data,
            'collection_time': datetime.now().isoformat()
        }
        
        return combined_data

# Initialize collector
collector = StablecoinDataCollector()
current_data = collector.collect_all_data()
print(json.dumps(current_data, indent=2))

import sqlite3
import pandas as pd
from datetime import datetime, timedelta

class StablecoinDatabase:
    def __init__(self, db_path='stablecoin_data.db'):
        self.db_path = db_path
        self.init_database()
    
    def init_database(self):
        """Create database tables for stablecoin data"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS price_data (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                exchange TEXT NOT NULL,
                symbol TEXT NOT NULL,
                price REAL NOT NULL,
                volume REAL,
                change_24h REAL,
                timestamp TEXT NOT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS depeg_events (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                symbol TEXT NOT NULL,
                depeg_percentage REAL NOT NULL,
                duration_minutes INTEGER,
                max_deviation REAL,
                recovery_time TEXT,
                event_timestamp TEXT NOT NULL
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def store_price_data(self, exchange, symbol, price_data):
        """Store price data in database"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            INSERT INTO price_data (exchange, symbol, price, volume, change_24h, timestamp)
            VALUES (?, ?, ?, ?, ?, ?)
        ''', (
            exchange, 
            symbol, 
            price_data['price'],
            price_data.get('volume', 0),
            price_data.get('change_24h', 0),
            price_data['timestamp']
        ))
        
        conn.commit()
        conn.close()
    
    def get_recent_prices(self, symbol, hours=24):
        """Retrieve recent price data for analysis"""
        conn = sqlite3.connect(self.db_path)
        
        query = '''
            SELECT * FROM price_data 
            WHERE symbol = ? AND datetime(timestamp) > datetime('now', '-{} hours')
            ORDER BY timestamp DESC
        '''.format(hours)
        
        df = pd.read_sql_query(query, conn, params=(symbol,))
        conn.close()
        
        return df

# Initialize database
db = StablecoinDatabase()

class DepegRiskAnalyzer:
    def __init__(self):
        self.ollama_model = 'llama2:13b'
        self.risk_thresholds = {
            'minor': 0.005,    # 0.5% deviation
            'moderate': 0.015, # 1.5% deviation  
            'severe': 0.030,   # 3.0% deviation
            'critical': 0.050  # 5.0% deviation
        }
    
    def create_analysis_prompt(self, stablecoin_data, historical_context):
        """Generate detailed analysis prompt for Ollama"""
        prompt = f"""
        Analyze the following stablecoin market data for depeg risk:

        CURRENT MARKET DATA:
        {json.dumps(stablecoin_data, indent=2)}

        HISTORICAL CONTEXT (24h):
        {historical_context}

        ANALYSIS REQUIREMENTS:
        1. Calculate deviation from $1.00 peg for each stablecoin
        2. Identify unusual trading volume patterns
        3. Compare cross-exchange price differences
        4. Assess market sentiment indicators
        5. Predict likelihood of further depegging

        RISK CATEGORIES:
        - MINOR: 0-0.5% deviation (normal market fluctuation)
        - MODERATE: 0.5-1.5% deviation (increased monitoring)
        - SEVERE: 1.5-3.0% deviation (immediate attention)
        - CRITICAL: >3.0% deviation (emergency response)

        Provide analysis in this JSON format:
        {{
            "USDT": {{
                "current_price": float,
                "deviation_percent": float,
                "risk_level": "MINOR|MODERATE|SEVERE|CRITICAL",
                "confidence": float,
                "reasoning": "detailed explanation",
                "recommended_action": "specific recommendation"
            }},
            "USDC": {{ ... }},
            "DAI": {{ ... }},
            "market_summary": "overall market assessment",
            "alert_priority": "LOW|MEDIUM|HIGH|URGENT"
        }}
        """
        return prompt
    
    def analyze_depeg_risk(self, current_data, historical_data):
        """Run AI analysis on stablecoin data"""
        try:
            # Prepare historical context
            historical_summary = self.create_historical_summary(historical_data)
            
            # Generate analysis prompt
            prompt = self.create_analysis_prompt(current_data, historical_summary)
            
            # Query Ollama AI model
            response = ollama.chat(
                model=self.ollama_model,
                messages=[{
                    'role': 'system',
                    'content': 'You are an expert cryptocurrency risk analyst specializing in stablecoin stability analysis.'
                }, {
                    'role': 'user', 
                    'content': prompt
                }]
            )
            
            # Parse AI response
            analysis_text = response['message']['content']
            return self.parse_analysis_response(analysis_text)
            
        except Exception as e:
            print(f"Analysis error: {e}")
            return self.create_fallback_analysis(current_data)
    
    def create_historical_summary(self, historical_data):
        """Create concise historical context for AI analysis"""
        summary = {}
        
        for symbol in ['USDT', 'USDC', 'DAI']:
            symbol_data = historical_data.get(symbol, [])
            if symbol_data:
                prices = [float(d['price']) for d in symbol_data]
                summary[symbol] = {
                    'avg_price_24h': sum(prices) / len(prices),
                    'min_price_24h': min(prices),
                    'max_price_24h': max(prices),
                    'volatility': max(prices) - min(prices),
                    'data_points': len(prices)
                }
        
        return summary
    
    def parse_analysis_response(self, analysis_text):
        """Extract structured data from AI response"""
        try:
            # Find JSON in response text
            json_start = analysis_text.find('{')
            json_end = analysis_text.rfind('}') + 1
            
            if json_start >= 0 and json_end > json_start:
                json_str = analysis_text[json_start:json_end]
                return json.loads(json_str)
            else:
                raise ValueError("No valid JSON found in response")
                
        except Exception as e:
            print(f"Failed to parse AI response: {e}")
            return self.create_fallback_analysis({})
    
    def create_fallback_analysis(self, current_data):
        """Generate basic analysis when AI fails"""
        return {
            "error": "AI analysis unavailable",
            "fallback_mode": True,
            "timestamp": datetime.now().isoformat(),
            "message": "Using basic rule-based analysis"
        }

# Initialize analyzer
analyzer = DepegRiskAnalyzer()

import schedule
import time
from datetime import datetime
import json

class StablecoinMonitor:
    def __init__(self):
        self.collector = StablecoinDataCollector()
        self.analyzer = DepegRiskAnalyzer()
        self.database = StablecoinDatabase()
        self.alert_history = []
        
    def run_analysis_cycle(self):
        """Execute complete monitoring cycle"""
        try:
            print(f"🔍 Starting analysis cycle at {datetime.now()}")
            
            # Collect current market data
            current_data = self.collector.collect_all_data()
            self.store_current_data(current_data)
            
            # Get historical context
            historical_data = self.get_historical_context()
            
            # Run AI risk analysis
            risk_analysis = self.analyzer.analyze_depeg_risk(
                current_data, historical_data
            )
            
            # Process alerts
            self.process_risk_alerts(risk_analysis)
            
            # Log results
            self.log_analysis_results(risk_analysis)
            
            print("✅ Analysis cycle completed")
            
        except Exception as e:
            print(f"❌ Analysis cycle failed: {e}")
    
    def store_current_data(self, data):
        """Store collected data in database"""
        for exchange, exchange_data in data.items():
            if exchange == 'collection_time':
                continue
                
            for symbol, price_data in exchange_data.items():
                self.database.store_price_data(exchange, symbol, price_data)
    
    def get_historical_context(self):
        """Retrieve historical data for analysis"""
        historical_data = {}
        
        for symbol in ['USDT', 'USDC', 'DAI']:
            df = self.database.get_recent_prices(symbol, hours=24)
            if not df.empty:
                historical_data[symbol] = df.to_dict('records')
        
        return historical_data
    
    def process_risk_alerts(self, analysis):
        """Generate and send risk alerts based on analysis"""
        if analysis.get('error'):
            return
        
        alert_priority = analysis.get('alert_priority', 'LOW')
        
        if alert_priority in ['HIGH', 'URGENT']:
            alert = {
                'timestamp': datetime.now().isoformat(),
                'priority': alert_priority,
                'analysis': analysis,
                'alert_id': len(self.alert_history) + 1
            }
            
            self.alert_history.append(alert)
            self.send_alert(alert)
    
    def send_alert(self, alert):
        """Send alert notification (customize for your needs)"""
        print(f"🚨 STABLECOIN ALERT - Priority: {alert['priority']}")
        print(f"Alert ID: {alert['alert_id']}")
        print(f"Time: {alert['timestamp']}")
        
        # Print risk details for each stablecoin
        analysis = alert['analysis']
        for coin in ['USDT', 'USDC', 'DAI']:
            if coin in analysis:
                coin_data = analysis[coin]
                print(f"{coin}: {coin_data.get('risk_level', 'UNKNOWN')} - {coin_data.get('reasoning', 'No details')}")
        
        print("-" * 50)
        
        # TODO: Add email, SMS, Discord, or other notification methods
    
    def log_analysis_results(self, analysis):
        """Log analysis results for debugging"""
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'analysis': analysis
        }
        
        # Save to log file (rotate daily)
        log_filename = f"analysis_log_{datetime.now().strftime('%Y%m%d')}.json"
        
        try:
            with open(log_filename, 'a') as f:
                f.write(json.dumps(log_entry) + '\n')
        except Exception as e:
            print(f"Logging error: {e}")
    
    def start_monitoring(self):
        """Start continuous monitoring"""
        print("🚀 Starting stablecoin depeg monitoring system")
        print("Monitoring USDT, USDC, and DAI for depeg risks")
        
        # Schedule analysis every 5 minutes
        schedule.every(5).minutes.do(self.run_analysis_cycle)
        
        # Run initial analysis
        self.run_analysis_cycle()
        
        # Keep monitoring
        while True:
            schedule.run_pending()
            time.sleep(60)  # Check every minute

# Initialize and start monitoring
monitor = StablecoinMonitor()

# For testing, run a single analysis cycle
# monitor.run_analysis_cycle()

# For production, start continuous monitoring
# monitor.start_monitoring()

import numpy as np
from datetime import datetime, timedelta

class AdvancedRiskIndicators:
    def __init__(self):
        self.indicators = {}
        
    def calculate_bid_ask_spread(self, orderbook_data):
        """Analyze bid-ask spread widening as stress indicator"""
        spreads = {}
        
        for exchange, data in orderbook_data.items():
            bid = float(data.get('bid', 0))
            ask = float(data.get('ask', 0))
            
            if bid > 0 and ask > 0:
                spread = (ask - bid) / ((ask + bid) / 2) * 100
                spreads[exchange] = {
                    'spread_bps': round(spread * 100, 2),
                    'bid': bid,
                    'ask': ask,
                    'mid_price': (bid + ask) / 2
                }
        
        return spreads
    
    def detect_volume_anomalies(self, volume_data, lookback_days=7):
        """Identify unusual trading volume patterns"""
        anomalies = {}
        
        for symbol, volumes in volume_data.items():
            if len(volumes) < lookback_days:
                continue
                
            recent_volume = volumes[-1]
            avg_volume = np.mean(volumes[:-1])
            std_volume = np.std(volumes[:-1])
            
            # Z-score calculation
            z_score = (recent_volume - avg_volume) / std_volume if std_volume > 0 else 0
            
            anomalies[symbol] = {
                'current_volume': recent_volume,
                'avg_volume': avg_volume,
                'z_score': round(z_score, 2),
                'is_anomaly': abs(z_score) > 2.0,
                'anomaly_type': 'high' if z_score > 2.0 else 'low' if z_score < -2.0 else 'normal'
            }
        
        return anomalies
    
    def calculate_cross_exchange_arbitrage(self, price_data):
        """Measure arbitrage opportunities as stress indicator"""
        arbitrage_ops = {}
        exchanges = list(price_data.keys())
        
        for i, exchange1 in enumerate(exchanges):
            for exchange2 in exchanges[i+1:]:
                for symbol in price_data[exchange1]:
                    if symbol in price_data[exchange2]:
                        price1 = price_data[exchange1][symbol]['price']
                        price2 = price_data[exchange2][symbol]['price']
                        
                        arb_pct = abs(price1 - price2) / min(price1, price2) * 100
                        
                        arbitrage_ops[f"{symbol}_{exchange1}_{exchange2}"] = {
                            'arbitrage_percent': round(arb_pct, 4),
                            'price_difference': abs(price1 - price2),
                            'is_significant': arb_pct > 0.1  # >0.1% is significant
                        }
        
        return arbitrage_ops

# Integration with main analysis system
def enhanced_risk_analysis_prompt(stablecoin_data, risk_indicators):
    """Enhanced prompt including advanced risk indicators"""
    return f"""
    COMPREHENSIVE STABLECOIN DEPEG RISK ANALYSIS
    
    PRICE DATA:
    {json.dumps(stablecoin_data, indent=2)}
    
    ADVANCED RISK INDICATORS:
    
    Bid-Ask Spread Analysis:
    {json.dumps(risk_indicators.get('spreads', {}), indent=2)}
    
    Volume Anomaly Detection:
    {json.dumps(risk_indicators.get('volume_anomalies', {}), indent=2)}
    
    Cross-Exchange Arbitrage:
    {json.dumps(risk_indicators.get('arbitrage', {}), indent=2)}
    
    ANALYSIS FRAMEWORK:
    1. Price deviation from $1.00 peg (primary indicator)
    2. Bid-ask spread widening (liquidity stress)
    3. Volume spikes/drops (market panic/apathy)
    4. Cross-exchange price differences (arbitrage breakdown)
    5. Historical pattern matching
    
    ENHANCED RISK ASSESSMENT:
    Consider all indicators collectively. Widening spreads + volume anomalies + price deviation = higher risk.
    
    Provide enhanced JSON analysis including:
    - Risk scoring (0-100 scale)
    - Confidence intervals
    - Specific trigger identification
    - Recommended monitoring frequency
    - Portfolio impact assessment
    """

from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler
import numpy as np

class PatternRecognition:
    def __init__(self):
        self.scaler = StandardScaler()
        self.anomaly_detector = IsolationForest(contamination=0.1, random_state=42)
        self.is_trained = False
    
    def prepare_features(self, historical_data):
        """Extract features for ML analysis"""
        features = []
        
        for record in historical_data:
            feature_vector = [
                record.get('price', 1.0),
                record.get('volume', 0),
                record.get('change_24h', 0),
                abs(record.get('price', 1.0) - 1.0),  # deviation from peg
                record.get('volume', 0) * abs(record.get('price', 1.0) - 1.0)  # volume-weighted deviation
            ]
            features.append(feature_vector)
        
        return np.array(features)
    
    def train_anomaly_detection(self, training_data):
        """Train anomaly detection model on historical stable periods"""
        features = self.prepare_features(training_data)
        
        if len(features) > 10:  # Minimum data requirement
            features_scaled = self.scaler.fit_transform(features)
            self.anomaly_detector.fit(features_scaled)
            self.is_trained = True
            return True
        
        return False
    
    def detect_anomalies(self, current_data):
        """Detect anomalous patterns in current data"""
        if not self.is_trained:
            return {'error': 'Model not trained'}
        
        features = self.prepare_features([current_data])
        features_scaled = self.scaler.transform(features)
        
        anomaly_score = self.anomaly_detector.decision_function(features_scaled)[0]
        is_anomaly = self.anomaly_detector.predict(features_scaled)[0] == -1
        
        return {
            'anomaly_score': float(anomaly_score),
            'is_anomaly': bool(is_anomaly),
            'confidence': abs(float(anomaly_score))
        }

# Enhanced analyzer with ML integration
class MLEnhancedAnalyzer(DepegRiskAnalyzer):
    def __init__(self):
        super().__init__()
        self.pattern_recognition = PatternRecognition()
        self.risk_indicators = AdvancedRiskIndicators()
    
    def enhanced_analysis(self, current_data, historical_data):
        """Run enhanced analysis with ML and advanced indicators"""
        # Calculate advanced risk indicators
        risk_indicators = {
            'volume_anomalies': self.risk_indicators.detect_volume_anomalies(
                self.extract_volume_data(historical_data)
            ),
            'arbitrage': self.risk_indicators.calculate_cross_exchange_arbitrage(current_data)
        }
        
        # Run ML anomaly detection
        ml_results = {}
        for symbol in ['USDT', 'USDC', 'DAI']:
            if symbol in historical_data:
                # Train on historical data if needed
                if not self.pattern_recognition.is_trained:
                    self.pattern_recognition.train_anomaly_detection(historical_data[symbol])
                
                # Detect anomalies in current data
                current_symbol_data = self.extract_current_symbol_data(current_data, symbol)
                if current_symbol_data:
                    ml_results[symbol] = self.pattern_recognition.detect_anomalies(current_symbol_data)
        
        # Generate enhanced prompt
        enhanced_prompt = enhanced_risk_analysis_prompt(current_data, risk_indicators)
        
        # Run AI analysis with enhanced data
        ai_analysis = self.analyze_depeg_risk(current_data, historical_data)
        
        # Combine all results
        combined_analysis = {
            'ai_analysis': ai_analysis,
            'ml_anomalies': ml_results,
            'risk_indicators': risk_indicators,
            'timestamp': datetime.now().isoformat()
        }
        
        return combined_analysis
    
    def extract_volume_data(self, historical_data):
        """Extract volume data for anomaly detection"""
        volume_data = {}
        
        for symbol, records in historical_data.items():
            volumes = [record.get('volume', 0) for record in records]
            volume_data[symbol] = volumes
        
        return volume_data
    
    def extract_current_symbol_data(self, current_data, symbol):
        """Extract current data for specific symbol"""
        for exchange_data in current_data.values():
            if isinstance(exchange_data, dict):
                for pair, data in exchange_data.items():
                    if symbol in pair:
                        return data
        return None

# Initialize enhanced analyzer
enhanced_analyzer = MLEnhancedAnalyzer()

class AlertStrategy:
    def __init__(self, name, config):
        self.name = name
        self.config = config
        self.triggered_alerts = []
    
    def evaluate_conditions(self, analysis_data):
        """Evaluate if alert conditions are met"""
        conditions_met = []
        
        for condition in self.config['conditions']:
            result = self.check_condition(condition, analysis_data)
            conditions_met.append(result)
        
        # Check if trigger logic is satisfied
        trigger_logic = self.config.get('trigger_logic', 'any')
        
        if trigger_logic == 'all':
            should_alert = all(conditions_met)
        elif trigger_logic == 'any':
            should_alert = any(conditions_met)
        else:  # majority
            should_alert = sum(conditions_met) > len(conditions_met) / 2
        
        return should_alert, conditions_met
    
    def check_condition(self, condition, data):
        """Check individual alert condition"""
        condition_type = condition['type']
        
        if condition_type == 'price_deviation':
            return self.check_price_deviation(condition, data)
        elif condition_type == 'volume_spike':
            return self.check_volume_spike(condition, data)
        elif condition_type == 'cross_exchange_spread':
            return self.check_spread_condition(condition, data)
        elif condition_type == 'ml_anomaly':
            return self.check_ml_anomaly(condition, data)
        
        return False
    
    def check_price_deviation(self, condition, data):
        """Check price deviation conditions"""
        symbol = condition['symbol']
        threshold = condition['threshold']
        
        ai_analysis = data.get('ai_analysis', {})
        if symbol in ai_analysis:
            deviation = ai_analysis[symbol].get('deviation_percent', 0)
            return abs(deviation) > threshold
        
        return False
    
    def check_volume_spike(self, condition, data):
        """Check volume anomaly conditions"""
        symbol = condition['symbol']
        z_score_threshold = condition.get('z_score_threshold', 2.0)
        
        risk_indicators = data.get('risk_indicators', {})
        volume_anomalies = risk_indicators.get('volume_anomalies', {})
        
        if symbol in volume_anomalies:
            z_score = volume_anomalies[symbol].get('z_score', 0)
            return abs(z_score) > z_score_threshold
        
        return False
    
    def check_ml_anomaly(self, condition, data):
        """Check ML anomaly detection results"""
        symbol = condition['symbol']
        confidence_threshold = condition.get('confidence_threshold', 0.5)
        
        ml_anomalies = data.get('ml_anomalies', {})
        if symbol in ml_anomalies:
            is_anomaly = ml_anomalies[symbol].get('is_anomaly', False)
            confidence = ml_anomalies[symbol].get('confidence', 0)
            return is_anomaly and confidence > confidence_threshold
        
        return False

# Pre-configured alert strategies
STRATEGY_CONFIGS = {
    'conservative_hodler': {
        'name': 'Conservative HODL Strategy',
        'description': 'Alerts for major depeg events that threaten long-term holdings',
        'conditions': [
            {
                'type': 'price_deviation',
                'symbol': 'USDT',
                'threshold': 0.02  # 2% deviation
            },
            {
                'type': 'price_deviation', 
                'symbol': 'USDC',
                'threshold': 0.015  # 1.5% deviation
            }
        ],
        'trigger_logic': 'any',
        'cooldown_minutes': 60
    },
    
    'active_trader': {
        'name': 'Active Trading Strategy',
        'description': 'Sensitive alerts for trading opportunities',
        'conditions': [
            {
                'type': 'price_deviation',
                'symbol': 'USDT',
                'threshold': 0.005  # 0.5% deviation
            },
            {
                'type': 'volume_spike',
                'symbol': 'USDT',
                'z_score_threshold': 1.5
            },
            {
                'type': 'ml_anomaly',
                'symbol': 'USDT',
                'confidence_threshold': 0.3
            }
        ],
        'trigger_logic': 'any',
        'cooldown_minutes': 5
    },
    
    'defi_yield_farmer': {
        'name': 'DeFi Yield Farming Strategy', 
        'description': 'DAI-focused monitoring for DeFi positions',
        'conditions': [
            {
                'type': 'price_deviation',
                'symbol': 'DAI',
                'threshold': 0.01  # 1% deviation
            },
            {
                'type': 'cross_exchange_spread',
                'symbol': 'DAI',
                'threshold': 0.005  # 0.5% spread
            }
        ],
        'trigger_logic': 'any',
        'cooldown_minutes': 15
    }
}

class CustomAlertManager:
    def __init__(self):
        self.strategies = {}
        self.load_strategies()
    
    def load_strategies(self):
        """Load predefined alert strategies"""
        for strategy_id, config in STRATEGY_CONFIGS.items():
            self.strategies[strategy_id] = AlertStrategy(strategy_id, config)
    
    def add_custom_strategy(self, strategy_id, config):
        """Add user-defined alert strategy"""
        self.strategies[strategy_id] = AlertStrategy(strategy_id, config)
    
    def process_alerts(self, analysis_data):
        """Process all alert strategies against current data"""
        triggered_strategies = []
        
        for strategy_id, strategy in self.strategies.items():
            should_alert, conditions = strategy.evaluate_conditions(analysis_data)
            
            if should_alert:
                alert_data = {
                    'strategy_id': strategy_id,
                    'strategy_name': strategy.name,
                    'timestamp': datetime.now().isoformat(),
                    'conditions_met': conditions,
                    'analysis_data': analysis_data
                }
                
                triggered_strategies.append(alert_data)
                strategy.triggered_alerts.append(alert_data)
        
        return triggered_strategies

# Integration with monitoring system
alert_manager = CustomAlertManager()

# Example: Add custom strategy for institutional users
institutional_config = {
    'name': 'Institutional Risk Management',
    'description': 'Multi-stablecoin monitoring for large positions',
    'conditions': [
        {'type': 'price_deviation', 'symbol': 'USDT', 'threshold': 0.008},
        {'type': 'price_deviation', 'symbol': 'USDC', 'threshold': 0.008},
        {'type': 'price_deviation', 'symbol': 'DAI', 'threshold': 0.012},
        {'type': 'volume_spike', 'symbol': 'USDT', 'z_score_threshold': 2.5}
    ],
    'trigger_logic': 'majority',
    'cooldown_minutes': 30
}

alert_manager.add_custom_strategy('institutional', institutional_config)

import plotly.graph_objects as go
from plotly.subplots import make_subplots
import plotly.express as px

class StablecoinDashboard:
    def __init__(self):
        self.colors = {
            'USDT': '#26a69a',
            'USDC': '#2196f3', 
            'DAI': '#ff9800',
            'danger': '#f44336',
            'warning': '#ff9800',
            'safe': '#4caf50'
        }
    
    def create_price_deviation_chart(self, price_data):
        """Create real-time price deviation visualization"""
        fig = make_subplots(
            rows=3, cols=1,
            subplot_titles=['USDT Deviation', 'USDC Deviation', 'DAI Deviation'],
            shared_xaxes=True,
            vertical_spacing=0.05
        )
        
        stablecoins = ['USDT', 'USDC', 'DAI']
        
        for i, coin in enumerate(stablecoins, 1):
            if coin in price_data:
                data = price_data[coin]
                timestamps = [d['timestamp'] for d in data]
                deviations = [(d['price'] - 1.0) * 100 for d in data]
                
                # Add deviation line
                fig.add_trace(
                    go.Scatter(
                        x=timestamps,
                        y=deviations,
                        mode='lines+markers',
                        name=f'{coin} Deviation',
                        line=dict(color=self.colors[coin], width=2),
                        marker=dict(size=4)
                    ),
                    row=i, col=1
                )
                
                # Add danger zones
                fig.add_hline(
                    y=1.0, line_dash="dash", line_color="orange",
                    annotation_text="1% Deviation", row=i, col=1
                )
                fig.add_hline(
                    y=-1.0, line_dash="dash", line_color="orange", row=i, col=1
                )
                fig.add_hline(
                    y=3.0, line_dash="dash", line_color="red",
                    annotation_text="Critical Level", row=i, col=1
                )
                fig.add_hline(
                    y=-3.0, line_dash="dash", line_color="red", row=i, col=1
                )
        
        fig.update_layout(
            title="Stablecoin Price Deviation Monitor",
            height=600,
            showlegend=True
        )
        
        fig.update_yaxes(title_text="Deviation %")
        
        return fig
    
    def create_risk_heatmap(self, current_analysis):
        """Create risk level heatmap"""
        risk_levels = {'MINOR': 1, 'MODERATE': 2, 'SEVERE': 3, 'CRITICAL': 4}
        
        coins = []
        risk_scores = []
        risk_labels = []
        
        ai_analysis = current_analysis.get('ai_analysis', {})
        
        for coin in ['USDT', 'USDC', 'DAI']:
            if coin in ai_analysis:
                coins.append(coin)
                risk_level = ai_analysis[coin].get('risk_level', 'MINOR')
                risk_scores.append(risk_levels.get(risk_level, 1))
                risk_labels.append(risk_level)
        
        fig = go.Figure(data=go.Heatmap(
            z=[risk_scores],
            x=coins,
            y=['Risk Level'],
            text=[risk_labels],
            texttemplate="%{text}",
            textfont={"size": 16},
            colorscale=[[0, '#4caf50'], [0.33, '#ff9800'], [0.66, '#f44336'], [1, '#d32f2f']],
            showscale=True,
            colorbar=dict(
                title="Risk Level",
                tickvals=[1, 2, 3, 4],
                ticktext=['Minor', 'Moderate', 'Severe', 'Critical']
            )
        ))
        
        fig.update_layout(
            title="Current Stablecoin Risk Levels",
            height=200,
            width=400
        )
        
        return fig
    
    def create_volume_analysis_chart(self, volume_data):
        """Create volume anomaly analysis chart"""
        fig = go.Figure()
        
        for coin, data in volume_data.items():
            z_score = data.get('z_score', 0)
            current_volume = data.get('current_volume', 0)
            avg_volume = data.get('avg_volume', 0)
            
            # Bar chart for volume comparison
            fig.add_trace(go.Bar(
                name=f'{coin} Current',
                x=[coin],
                y=[current_volume],
                marker_color=self.colors.get(coin, '#888888')
            ))
            
            fig.add_trace(go.Bar(
                name=f'{coin} Average',
                x=[coin],
                y=[avg_volume],
                marker_color=self.colors.get(coin, '#888888'),
                opacity=0.5
            ))
        
        fig.update_layout(
            title="Volume Analysis - Current vs Historical Average",
            yaxis_title="Volume",
            barmode='group'
        )
        
        return fig
    
    def generate_dashboard_html(self, analysis_data):
        """Generate complete HTML dashboard"""
        # Extract data components
        price_data = self.extract_price_history(analysis_data)
        volume_data = analysis_data.get('risk_indicators', {}).get('volume_anomalies', {})
        
        # Create charts
        deviation_chart = self.create_price_deviation_chart(price_data)
        risk_heatmap = self.create_risk_heatmap(analysis_data)
        volume_chart = self.create_volume_analysis_chart(volume_data)
        
        # Convert to HTML
        dashboard_html = f"""
        <!DOCTYPE html>
        <html>
        <head>
            <title>Stablecoin Depeg Risk Monitor</title>
            <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 20px; }}
                .dashboard-header {{ text-align: center; margin-bottom: 30px; }}
                .chart-container {{ margin: 20px 0; }}
                .metrics-grid {{ display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 20px; margin: 20px 0; }}
                .metric-card {{ 
                    border: 1px solid #ddd; 
                    padding: 15px; 
                    border-radius: 8px; 
                    text-align: center; 
                }}
            </style>
        </head>
        <body>
            <div class="dashboard-header">
                <h1>🛡️ Stablecoin Depeg Risk Monitor</h1>
                <p>Real-time monitoring powered by Ollama AI</p>
                <p>Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}</p>
            </div>
            
            <div class="metrics-grid">
                {self.generate_metric_cards(analysis_data)}
            </div>
            
            <div class="chart-container">
                {deviation_chart.to_html(include_plotlyjs=False, div_id="deviation-chart")}
            </div>
            
            <div class="chart-container">
                {risk_heatmap.to_html(include_plotlyjs=False, div_id="risk-heatmap")}
            </div>
            
            <div class="chart-container">
                {volume_chart.to_html(include_plotlyjs=False, div_id="volume-chart")}
            </div>
            
            <script>
                // Auto-refresh every 5 minutes
                setTimeout(function() {{
                    location.reload();
                }}, 300000);
            </script>
        </body>
        </html>
        """
        
        return dashboard_html
    
    def generate_metric_cards(self, analysis_data):
        """Generate HTML for metric cards"""
        ai_analysis = analysis_data.get('ai_analysis', {})
        cards_html = ""
        
        for coin in ['USDT', 'USDC', 'DAI']:
            if coin in ai_analysis:
                coin_data = ai_analysis[coin]
                price = coin_data.get('current_price', 1.0)
                risk_level = coin_data.get('risk_level', 'UNKNOWN')
                deviation = coin_data.get('deviation_percent', 0)
                
                color = self.get_risk_color(risk_level)
                
                cards_html += f"""
                <div class="metric-card" style="border-color: {color};">
                    <h3>{coin}</h3>
                    <p><strong>Price:</strong> ${price:.6f}</p>
                    <p><strong>Deviation:</strong> {deviation:.3f}%</p>
                    <p><strong>Risk:</strong> <span style="color: {color};">{risk_level}</span></p>
                </div>
                """
        
        return cards_html
    
    def get_risk_color(self, risk_level):
        """Get color code for risk level"""
        colors = {
            'MINOR': '#4caf50',
            'MODERATE': '#ff9800', 
            'SEVERE': '#f44336',
            'CRITICAL': '#d32f2f'
        }
        return colors.get(risk_level, '#888888')
    
    def extract_price_history(self, analysis_data):
        """Extract price history for charting"""
        # This would typically pull from database
        # For demo, return sample data structure
        return {
            'USDT': [
                {'timestamp': datetime.now().isoformat(), 'price': 0.9995},
                {'timestamp': (datetime.now() - timedelta(hours=1)).isoformat(), 'price': 0.9998}
            ],
            'USDC': [
                {'timestamp': datetime.now().isoformat(), 'price': 1.0001},
                {'timestamp': (datetime.now() - timedelta(hours=1)).isoformat(), 'price': 1.0000}
            ],
            'DAI': [
                {'timestamp': datetime.now().isoformat(), 'price': 0.9989},
                {'timestamp': (datetime.now() - timedelta(hours=1)).isoformat(), 'price': 0.9992}
            ]
        }

# Initialize dashboard
dashboard = StablecoinDashboard()

# Example: Generate dashboard from analysis results
# dashboard_html = dashboard.generate_dashboard_html(analysis_results)
# with open('stablecoin_dashboard.html', 'w') as f:
#     f.write(dashboard_html)

# Dockerfile
FROM python:3.11-slim

# Install system dependencies
RUN apt-get update && apt-get install -y \
    curl \
    sqlite3 \
    && rm -rf /var/lib/apt/lists/*

# Install Ollama
RUN curl -fsSL https://ollama.ai/install.sh | sh

# Set working directory
WORKDIR /app

# Copy requirements and install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Create data directory
RUN mkdir -p /app/data

# Set environment variables
ENV PYTHONPATH=/app
ENV OLLAMA_HOST=0.0.0.0

# Expose ports
EXPOSE 8000

# Start script
COPY start.sh .
RUN chmod +x start.sh

CMD ["./start.sh"]

#!/bin/bash
# start.sh

# Start Ollama service
ollama serve &

# Wait for Ollama to be ready
sleep 10

# Pull required models
ollama pull llama2:13b
ollama pull codellama:13b

# Start monitoring application
python -m src.monitor --config production.yaml

# production.yaml
monitoring:
  interval_seconds: 300  # 5 minutes
  data_retention_days: 90
  max_alerts_per_hour: 12

exchanges:
  binance:
    enabled: true
    rate_limit_ms: 1000
    timeout_seconds: 30
  coinbase:
    enabled: true
    rate_limit_ms: 1000
    timeout_seconds: 30

ollama:
  model: "llama2:13b"
  temperature: 0.1
  max_tokens: 2048
  timeout_seconds: 60

database:
  type: "postgresql"  # Switch to PostgreSQL for production
  host: "${DB_HOST}"
  port: 5432
  database: "stablecoin_monitor"
  username: "${DB_USER}"
  password: "${DB_PASSWORD}"
  
alerts:
  discord_webhook: "${DISCORD_WEBHOOK_URL}"
  email_smtp: "${SMTP_SERVER}"
  slack_webhook: "${SLACK_WEBHOOK_URL}"

logging:
  level: "INFO"
  file: "/app/logs/monitor.log"
  max_size_mb: 100
  backup_count: 5

security:
  api_key_required: true
  allowed_ips: ["10.0.0.0/8", "172.16.0.0/12"]
  rate_limit_per_minute: 60

import logging
import os
import yaml
import psycopg2
from typing import Dict, List, Optional
import smtplib
from email.mime.text import MIMEText
import requests

class ProductionStablecoinMonitor:
    def __init__(self, config_path: str):
        self.config = self.load_config(config_path)
        self.setup_logging()
        self.setup_database()
        self.setup_alerts()
        
        # Initialize core components
        self.collector = StablecoinDataCollector()
        self.analyzer = MLEnhancedAnalyzer()
        self.alert_manager = CustomAlertManager()
        self.dashboard = StablecoinDashboard()
        
        self.is_running = False
        
    def load_config(self, config_path: str) -> Dict:
        """Load production configuration"""
        with open(config_path, 'r') as f:
            config = yaml.safe_load(f)
        
        # Replace environment variables
        config = self.replace_env_vars(config)
        return config
    
    def replace_env_vars(self, config: Dict) -> Dict:
        """Replace ${VAR} with environment variables"""
        def replace_recursive(obj):
            if isinstance(obj, dict):
                return {k: replace_recursive(v) for k, v in obj.items()}
            elif isinstance(obj, list):
                return [replace_recursive(item) for item in obj]
            elif isinstance(obj, str) and obj.startswith('${') and obj.endswith('}'):
                env_var = obj[2:-1]
                return os.getenv(env_var, obj)
            return obj
        
        return replace_recursive(config)
    
    def setup_logging(self):
        """Configure production logging"""
        log_config = self.config.get('logging', {})
        
        logging.basicConfig(
            level=getattr(logging, log_config.get('level', 'INFO')),
            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler(log_config.get('file', 'monitor.log')),
                logging.StreamHandler()
            ]
        )
        
        self.logger = logging.getLogger(__name__)
        self.logger.info("Production monitoring system initialized")
    
    def setup_database(self):
        """Setup production database connection"""
        db_config = self.config.get('database', {})
        
        if db_config.get('type') == 'postgresql':
            self.db_connection = psycopg2.connect(
                host=db_config['host'],
                port=db_config['port'],
                database=db_config['database'],
                user=db_config['username'],
                password=db_config['password']
            )
            self.logger.info("Connected to PostgreSQL database")
        else:
            # Fallback to SQLite
            self.database = StablecoinDatabase()
            self.logger.info("Using SQLite database")
    
    def setup_alerts(self):
        """Configure production alert channels"""
        self.alert_channels = {}
        
        # Discord webhook
        discord_url = self.config.get('alerts', {}).get('discord_webhook')
        if discord_url:
            self.alert_channels['discord'] = discord_url
        
        # Email SMTP
        smtp_server = self.config.get('alerts', {}).get('email_smtp')
        if smtp_server:
            self.alert_channels['email'] = smtp_server
        
        # Slack webhook
        slack_url = self.config.get('alerts', {}).get('slack_webhook')
        if slack_url:
            self.alert_channels['slack'] = slack_url
    
    def send_production_alert(self, alert_data: Dict):
        """Send alerts through configured channels"""
        message = self.format_alert_message(alert_data)
        
        # Send to Discord
        if 'discord' in self.alert_channels:
            self.send_discord_alert(message, alert_data)
        
        # Send to Slack
        if 'slack' in self.alert_channels:
            self.send_slack_alert(message, alert_data)
        
        # Send email
        if 'email' in self.alert_channels:
            self.send_email_alert(message, alert_data)
    
    def send_discord_alert(self, message: str, alert_data: Dict):
        """Send alert to Discord channel"""
        try:
            webhook_url = self.alert_channels['discord']
            
            # Create Discord embed
            embed = {
                "title": "🚨 Stablecoin Depeg Alert",
                "description": message,
                "color": self.get_alert_color(alert_data.get('priority', 'LOW')),
                "timestamp": datetime.now().isoformat(),
                "fields": self.create_discord_fields(alert_data)
            }
            
            payload = {"embeds": [embed]}
            
            response = requests.post(webhook_url, json=payload)
            response.raise_for_status()
            
            self.logger.info("Discord alert sent successfully")
            
        except Exception as e:
            self.logger.error(f"Failed to send Discord alert: {e}")
    
    def send_slack_alert(self, message: str, alert_data: Dict):
        """Send alert to Slack channel"""
        try:
            webhook_url = self.alert_channels['slack']
            
            payload = {
                "text": "🚨 Stablecoin Depeg Alert",
                "attachments": [{
                    "color": "danger" if alert_data.get('priority') in ['HIGH', 'URGENT'] else "warning",
                    "fields": [
                        {"title": "Alert", "value": message, "short": False},
                        {"title": "Priority", "value": alert_data.get('priority', 'Unknown'), "short": True},
                        {"title": "Time", "value": datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC'), "short": True}
                    ]
                }]
            }
            
            response = requests.post(webhook_url, json=payload)
            response.raise_for_status()
            
            self.logger.info("Slack alert sent successfully")
            
        except Exception as e:
            self.logger.error(f"Failed to send Slack alert: {e}")
    
    def format_alert_message(self, alert_data: Dict) -> str:
        """Format alert message for notifications"""
        analysis = alert_data.get('analysis', {})
        ai_analysis = analysis.get('ai_analysis', {})
        
        message_parts = []
        
        for coin in ['USDT', 'USDC', 'DAI']:
            if coin in ai_analysis:
                coin_data = ai_analysis[coin]
                risk_level = coin_data.get('risk_level', 'UNKNOWN')
                price = coin_data.get('current_price', 0)
                deviation = coin_data.get('deviation_percent', 0)
                
                if risk_level in ['SEVERE', 'CRITICAL']:
                    message_parts.append(
                        f"{coin}: ${price:.6f} ({deviation:+.3f}%) - {risk_level}"
                    )
        
        if message_parts:
            return "Depeg risk detected:\n" + "\n".join(message_parts)
        else:
            return "General stablecoin monitoring alert triggered"
    
    def get_alert_color(self, priority: str) -> int:
        """Get Discord embed color for priority level"""
        colors = {
            'LOW': 0x4CAF50,      # Green
            'MEDIUM': 0xFF9800,   # Orange
            'HIGH': 0xF44336,     # Red
            'URGENT': 0xD32F2F    # Dark red
        }
        return colors.get(priority, 0x888888)
    
    def create_discord_fields(self, alert_data: Dict) -> List[Dict]:
        """Create Discord embed fields"""
        fields = [
            {
                "name": "Priority",
                "value": alert_data.get('priority', 'Unknown'),
                "inline": True
            },
            {
                "name": "Strategy",
                "value": alert_data.get('strategy_name', 'General'),
                "inline": True
            }
        ]
        
        analysis = alert_data.get('analysis', {})
        ai_analysis = analysis.get('ai_analysis', {})
        
        for coin in ['USDT', 'USDC', 'DAI']:
            if coin in ai_analysis:
                coin_data = ai_analysis[coin]
                fields.append({
                    "name": coin,
                    "value": f"${coin_data.get('current_price', 0):.6f} - {coin_data.get('risk_level', 'UNKNOWN')}",
                    "inline": True
                })
        
        return fields
    
    def run_production_cycle(self):
        """Execute production monitoring cycle with error handling"""
        try:
            self.logger.debug("Starting production monitoring cycle")
            
            # Collect data with retries
            current_data = self.collect_with_retries()
            if not current_data:
                self.logger.warning("Failed to collect market data")
                return
            
            # Store data
            self.store_production_data(current_data)
            
            # Get historical context
            historical_data = self.get_production_historical_data()
            
            # Run enhanced analysis
            analysis_result = self.analyzer.enhanced_analysis(current_data, historical_data)
            
            # Process alerts
            triggered_alerts = self.alert_manager.process_alerts(analysis_result)
            
            # Send production alerts
            for alert in triggered_alerts:
                self.send_production_alert(alert)
            
            # Update dashboard
            self.update_production_dashboard(analysis_result)
            
            # Health check
            self.perform_health_check()
            
            self.logger.debug("Production monitoring cycle completed successfully")
            
        except Exception as e:
            self.logger.error(f"Production monitoring cycle failed: {e}", exc_info=True)
            self.handle_system_error(e)
    
    def collect_with_retries(self, max_retries: int = 3) -> Optional[Dict]:
        """Collect data with retry logic"""
        for attempt in range(max_retries):
            try:
                return self.collector.collect_all_data()
            except Exception as e:
                self.logger.warning(f"Data collection attempt {attempt + 1} failed: {e}")
                if attempt == max_retries - 1:
                    return None
                time.sleep(2 ** attempt)  # Exponential backoff
        
        return None
    
    def start_production_monitoring(self):
        """Start production monitoring with scheduling"""
        self.logger.info("Starting production stablecoin monitoring system")
        self.is_running = True
        
        interval = self.config.get('monitoring', {}).get('interval_seconds', 300)
        
        # Schedule monitoring cycles
        schedule.every(interval).seconds.do(self.run_production_cycle)
        
        # Run initial cycle
        self.run_production_cycle()
        
        # Main monitoring loop
        while self.is_running:
            try:
                schedule.run_pending()
                time.sleep(30)  # Check every 30 seconds
            except KeyboardInterrupt:
                self.logger.info("Received shutdown signal")
                self.shutdown()
                break
            except Exception as e:
                self.logger.error(f"Monitoring loop error: {e}", exc_info=True)
                time.sleep(60)  # Wait before retrying
    
    def shutdown(self):
        """Graceful shutdown"""
        self.logger.info("Shutting down production monitoring system")
        self.is_running = False
        
        if hasattr(self, 'db_connection'):
            self.db_connection.close()

# Production entry point
if __name__ == "__main__":
    import sys
    
    config_path = sys.argv[1] if len(sys.argv) > 1 else "production.yaml"
    
    monitor = ProductionStablecoinMonitor(config_path)
    monitor.start_production_monitoring()