European Crypto ETF Tracker: Ollama EU vs US Regulatory Approach - Complete Guide 2025

# Install Ollama (Linux/macOS)
curl -fsSL https://ollama.ai/install.sh | sh

# Start Ollama service
ollama serve

# Pull recommended models for financial analysis
ollama pull llama3.1:8b
ollama pull codellama:7b

# requirements.txt
pip install pandas numpy requests ollama-python
pip install ccxt yfinance alpha_vantage
pip install matplotlib seaborn plotly
pip install schedule python-dotenv

# etf_data_collector.py
import requests
import pandas as pd
import ccxt
from datetime import datetime, timedelta
import ollama

class EuropeanCryptoETFCollector:
    def __init__(self):
        self.exchanges = {
            'binance': ccxt.binance(),
            'kraken': ccxt.kraken(),
            'coinbase': ccxt.coinbasepro()
        }
        self.eu_etf_symbols = {
            'BTCE': 'BTCetc Bitcoin Exchange Traded Crypto',
            'ETHE': 'BTCetc Ethereum Exchange Traded Crypto',
            'HODL': 'ETC Group Digital Assets',
            'ABTC': 'CoinShares Physical Bitcoin'
        }
        
    def fetch_etf_data(self, symbol, timeframe='1d', limit=100):
        """Fetch OHLCV data for European crypto ETFs"""
        try:
            # Fetch from multiple exchanges for comparison
            data_points = {}
            for exchange_name, exchange in self.exchanges.items():
                if exchange.has['fetchOHLCV']:
                    ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
                    df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
                    df['datetime'] = pd.to_datetime(df['timestamp'], unit='ms')
                    data_points[exchange_name] = df
            
            return data_points
        except Exception as e:
            print(f"Error fetching ETF data for {symbol}: {e}")
            return None
    
    def get_regulatory_compliance_data(self, etf_symbol):
        """Extract MiCA compliance information for EU ETFs"""
        compliance_metrics = {
            'mica_compliant': True,
            'authorization_date': '2025-01-01',
            'aum_millions': 0,
            'management_fee': 0.0,
            'regulatory_risk_score': 'Low'
        }
        
        # Add specific compliance checks based on MiCA requirements
        if etf_symbol in self.eu_etf_symbols:
            compliance_metrics['licensed_eu'] = True
            compliance_metrics['passporting_enabled'] = True
        
        return compliance_metrics

# ollama_analyzer.py
import ollama
import json
from typing import Dict, List

class OllamaETFAnalyzer:
    def __init__(self, model_name="llama3.1:8b"):
        self.model = model_name
        self.system_prompt = """You are a specialized financial analyst focused on European cryptocurrency ETFs and regulatory compliance. Analyze market data considering MiCA regulations and provide actionable insights."""
    
    def analyze_etf_performance(self, etf_data: Dict, regulatory_context: Dict) -> Dict:
        """Analyze ETF performance with regulatory considerations"""
        prompt = f"""
        Analyze this European crypto ETF data:
        ETF Data: {json.dumps(etf_data, indent=2)}
        Regulatory Context: {json.dumps(regulatory_context, indent=2)}
        
        Provide analysis covering:
        1. Performance trends
        2. MiCA compliance impact
        3. Risk assessment
        4. Comparison with US ETF alternatives
        5. Investment recommendations
        
        Format response as JSON with clear metrics.
        """
        
        try:
            response = ollama.chat(
                model=self.model,
                messages=[
                    {'role': 'system', 'content': self.system_prompt},
                    {'role': 'user', 'content': prompt}
                ]
            )
            return self._parse_analysis_response(response['message']['content'])
        except Exception as e:
            print(f"Ollama analysis error: {e}")
            return {'error': str(e)}
    
    def compare_eu_us_regulations(self, etf_symbol: str) -> Dict:
        """Compare EU MiCA vs US SEC regulations for specific ETF"""
        prompt = f"""
        Compare regulatory frameworks for crypto ETF {etf_symbol}:
        
        EU MiCA Framework:
        - Comprehensive licensing
        - Passporting across 27 countries
        - Stablecoin reserve requirements
        - Consumer protection focus
        
        US SEC/CFTC Framework:
        - Enforcement-driven approach
        - Securities vs commodities classification
        - Limited ETF approvals
        - Multiple agency oversight
        
        Analyze advantages, risks, and investment implications.
        Provide specific recommendations for European investors.
        """
        
        response = ollama.chat(
            model=self.model,
            messages=[{'role': 'user', 'content': prompt}]
        )
        
        return self._parse_regulatory_comparison(response['message']['content'])
    
    def _parse_analysis_response(self, response: str) -> Dict:
        """Parse Ollama response into structured data"""
        try:
            # Extract JSON from response if present
            import re
            json_match = re.search(r'\{.*\}', response, re.DOTALL)
            if json_match:
                return json.loads(json_match.group())
            else:
                return {'analysis': response, 'structured_data': False}
        except:
            return {'raw_analysis': response}

# dashboard.py
import streamlit as st
import plotly.graph_objects as go
import plotly.express as px
from datetime import datetime, timedelta

class EuropeanETFDashboard:
    def __init__(self, collector, analyzer):
        self.collector = collector
        self.analyzer = analyzer
        
    def create_dashboard(self):
        """Create Streamlit dashboard for ETF tracking"""
        st.set_page_config(
            page_title="European Crypto ETF Tracker",
            page_icon="📊",
            layout="wide"
        )
        
        st.title("🇪🇺 European Crypto ETF Tracker with Ollama Analysis")
        st.sidebar.title("Configuration")
        
        # ETF Selection
        selected_etfs = st.sidebar.multiselect(
            "Select ETFs to Track",
            list(self.collector.eu_etf_symbols.keys()),
            default=['BTCE', 'ETHE']
        )
        
        # Regulatory Filter
        regulatory_view = st.sidebar.selectbox(
            "Regulatory Perspective",
            ["MiCA Compliance", "US Comparison", "Global View"]
        )
        
        # Main Dashboard Layout
        col1, col2, col3 = st.columns([2, 1, 1])
        
        with col1:
            self._create_performance_chart(selected_etfs)
            
        with col2:
            self._create_compliance_metrics(selected_etfs)
            
        with col3:
            self._create_regulatory_alerts()
        
        # Ollama Analysis Section
        st.subheader("🤖 AI-Powered Analysis")
        if st.button("Generate Ollama Analysis"):
            self._display_ollama_analysis(selected_etfs, regulatory_view)
    
    def _create_performance_chart(self, etf_symbols):
        """Create interactive performance chart"""
        st.subheader("ETF Performance Tracking")
        
        # Fetch and display data for selected ETFs
        for symbol in etf_symbols:
            etf_data = self.collector.fetch_etf_data(symbol)
            if etf_data:
                # Create candlestick chart
                fig = go.Figure()
                for exchange, data in etf_data.items():
                    fig.add_trace(go.Scatter(
                        x=data['datetime'],
                        y=data['close'],
                        name=f"{symbol} ({exchange})",
                        mode='lines'
                    ))
                
                fig.update_layout(
                    title=f"{symbol} - {self.collector.eu_etf_symbols[symbol]}",
                    xaxis_title="Date",
                    yaxis_title="Price (EUR)",
                    height=400
                )
                st.plotly_chart(fig, use_container_width=True)
    
    def _create_compliance_metrics(self, etf_symbols):
        """Display MiCA compliance metrics"""
        st.subheader("MiCA Compliance Status")
        
        for symbol in etf_symbols:
            compliance_data = self.collector.get_regulatory_compliance_data(symbol)
            
            # Compliance indicator
            if compliance_data['mica_compliant']:
                st.success(f"✅ {symbol}: MiCA Compliant")
            else:
                st.error(f"❌ {symbol}: Non-Compliant")
            
            # Key metrics
            st.metric("AUM", f"€{compliance_data['aum_millions']}M")
            st.metric("Management Fee", f"{compliance_data['management_fee']}%")
            st.metric("Risk Score", compliance_data['regulatory_risk_score'])
    
    def _display_ollama_analysis(self, etf_symbols, regulatory_view):
        """Display AI-generated analysis"""
        with st.spinner("Generating Ollama analysis..."):
            for symbol in etf_symbols:
                etf_data = self.collector.fetch_etf_data(symbol)
                compliance_data = self.collector.get_regulatory_compliance_data(symbol)
                
                analysis = self.analyzer.analyze_etf_performance(etf_data, compliance_data)
                
                st.subheader(f"Analysis: {symbol}")
                st.write(analysis.get('analysis', 'Analysis unavailable'))
                
                if regulatory_view == "US Comparison":
                    comparison = self.analyzer.compare_eu_us_regulations(symbol)
                    st.write("**Regulatory Comparison:**")
                    st.write(comparison)

# alert_system.py
import schedule
import time
from datetime import datetime
import smtplib
from email.mime.text import MimeText

class ETFAlertSystem:
    def __init__(self, analyzer, email_config):
        self.analyzer = analyzer
        self.email_config = email_config
        self.alert_thresholds = {
            'price_change': 5.0,  # 5% price change
            'volume_spike': 2.0,  # 2x average volume
            'regulatory_update': True
        }
    
    def check_regulatory_updates(self):
        """Monitor for MiCA and SEC regulatory changes"""
        prompt = """
        Check for recent regulatory updates affecting crypto ETFs:
        1. MiCA implementation changes
        2. SEC approval announcements
        3. CFTC commodity classifications
        4. European Banking Authority guidance
        
        Summarize any significant developments from the past 24 hours.
        """
        
        response = ollama.chat(
            model="llama3.1:8b",
            messages=[{'role': 'user', 'content': prompt}]
        )
        
        return response['message']['content']
    
    def send_alert(self, subject, message):
        """Send email alert for important updates"""
        try:
            msg = MimeText(message)
            msg['Subject'] = subject
            msg['From'] = self.email_config['from']
            msg['To'] = self.email_config['to']
            
            server = smtplib.SMTP(self.email_config['smtp_server'], 587)
            server.starttls()
            server.login(self.email_config['username'], self.email_config['password'])
            server.send_message(msg)
            server.quit()
            
            print(f"Alert sent: {subject}")
        except Exception as e:
            print(f"Failed to send alert: {e}")
    
    def run_monitoring(self):
        """Run continuous monitoring with scheduled checks"""
        schedule.every(1).hours.do(self.check_regulatory_updates)
        schedule.every(15).minutes.do(self.check_price_alerts)
        
        while True:
            schedule.run_pending()
            time.sleep(60)

# ollama_config.py
OLLAMA_CONFIG = {
    "model": "llama3.1:8b",
    "temperature": 0.1,  # Low temperature for consistent analysis
    "context_length": 4096,
    "system_prompt": """You are a European crypto ETF specialist with expertise in MiCA regulations. Provide precise, data-driven analysis focusing on compliance and market trends."""
}

def optimize_ollama_performance():
    """Optimize Ollama for financial analysis workloads"""
    # Model-specific optimizations
    optimizations = {
        "num_ctx": 4096,
        "num_predict": 512,
        "temperature": 0.1,
        "top_p": 0.9,
        "repeat_penalty": 1.1
    }
    return optimizations

def validate_etf_data(data_frame):
    """Validate ETF data quality and completeness"""
    validation_results = {
        'missing_values': data_frame.isnull().sum().to_dict(),
        'data_range_valid': True,
        'volume_consistency': True,
        'price_anomalies': []
    }
    
    # Check for price anomalies (>50% daily change)
    price_changes = data_frame['close'].pct_change()
    anomalies = price_changes[abs(price_changes) > 0.5]
    validation_results['price_anomalies'] = anomalies.tolist()
    
    return validation_results

# Ubuntu/Debian server preparation
sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip nginx supervisor redis-server

# Install Ollama in production
curl -fsSL https://ollama.ai/install.sh | sh
systemctl enable ollama
systemctl start ollama

# .env file for production
DATABASE_URL=postgresql://user:pass@localhost:5432/etf_tracker
REDIS_URL=redis://localhost:6379
OLLAMA_HOST=http://localhost:11434
API_RATE_LIMIT=100
MONITORING_INTERVAL=300

def handle_data_interruption(self, symbol, error_type):
    """Graceful handling of data feed issues"""
    fallback_sources = {
        'primary': 'coinmarketcap_api',
        'secondary': 'coingecko_api',
        'tertiary': 'cached_data'
    }
    
    for source in fallback_sources.values():
        try:
            data = self.fetch_from_source(source, symbol)
            if data:
                self.log_warning(f"Using fallback source: {source}")
                return data
        except Exception as e:
            continue
    
    return None

def optimize_ollama_query(self, query_type, data_size):
    """Optimize Ollama queries based on data complexity"""
    if data_size > 1000:  # Large dataset
        return {
            "model": "llama3.1:8b",
            "temperature": 0.05,
            "max_tokens": 256
        }
    else:  # Standard analysis
        return {
            "model": "llama3.1:8b", 
            "temperature": 0.1,
            "max_tokens": 512
        }