Crypto Bull Market Peak Predictor: Ollama Q1 2025 $180K Bitcoin Analysis

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

# Pull the required models
ollama pull llama3.1:70b
ollama pull codellama:34b
ollama pull mistral:7b

import ollama
import pandas as pd
import numpy as np
import yfinance as yf
from datetime import datetime, timedelta
import json

class CryptoBullMarketPredictor:
    def __init__(self):
        self.client = ollama.Client()
        self.btc_data = None
        self.indicators = {}
        
    def fetch_bitcoin_data(self, period="2y"):
        """Fetch Bitcoin price data from Yahoo Finance"""
        ticker = yf.Ticker("BTC-USD")
        self.btc_data = ticker.history(period=period)
        return self.btc_data
    
    def calculate_technical_indicators(self):
        """Calculate key bull market indicators"""
        df = self.btc_data.copy()
        
        # Moving averages
        df['MA_20'] = df['Close'].rolling(window=20).mean()
        df['MA_50'] = df['Close'].rolling(window=50).mean()
        df['MA_200'] = df['Close'].rolling(window=200).mean()
        
        # RSI calculation
        delta = df['Close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
        rs = gain / loss
        df['RSI'] = 100 - (100 / (1 + rs))
        
        # MVRV Z-Score (Market Value to Realized Value)
        # Simplified calculation for demonstration
        df['MVRV_Ratio'] = df['Close'] / df['Close'].rolling(window=365).mean()
        df['MVRV_ZScore'] = (df['MVRV_Ratio'] - df['MVRV_Ratio'].rolling(window=365).mean()) / df['MVRV_Ratio'].rolling(window=365).std()
        
        # Puell Multiple (Miner Revenue vs Historical Average)
        df['Daily_Issuance'] = 900  # Simplified: ~900 BTC mined daily
        df['Miner_Revenue'] = df['Close'] * df['Daily_Issuance']
        df['Puell_Multiple'] = df['Miner_Revenue'] / df['Miner_Revenue'].rolling(window=365).mean()
        
        self.indicators = df
        return df

def analyze_bull_market_phase(self):
    """Use Ollama to analyze current bull market phase"""
    
    # Get latest market data
    latest_data = self.indicators.tail(30)
    
    analysis_prompt = f"""
    You are a cryptocurrency market analyst specializing in bull market cycle analysis.
    
    Current Bitcoin Market Data:
    - Price: ${latest_data['Close'].iloc[-1]:,.2f}
    - 30-day change: {((latest_data['Close'].iloc[-1] / latest_data['Close'].iloc[-30]) - 1) * 100:.1f}%
    - RSI: {latest_data['RSI'].iloc[-1]:.1f}
    - MVRV Z-Score: {latest_data['MVRV_ZScore'].iloc[-1]:.2f}
    - Puell Multiple: {latest_data['Puell_Multiple'].iloc[-1]:.2f}
    - Above 200-day MA: {latest_data['Close'].iloc[-1] > latest_data['MA_200'].iloc[-1]}
    
    Historical Bull Market Peak Indicators:
    - RSI typically exceeds 80 near peaks
    - MVRV Z-Score above 7 indicates overvaluation
    - Puell Multiple above 4 suggests miner selling pressure
    - Price 10x+ above 200-day MA during peak euphoria
    
    Analysis Requirements:
    1. Assess current bull market phase (Early/Mid/Late/Peak)
    2. Calculate probability of reaching $180K by Q1 2025
    3. Identify key risk factors and warning signals
    4. Provide specific price levels to watch
    5. Suggest position management strategy
    
    Format your response as structured JSON with clear reasoning.
    """
    
    response = self.client.chat(
        model='llama3.1:70b',
        messages=[{'role': 'user', 'content': analysis_prompt}]
    )
    
    return response['message']['content']

def analyze_market_sentiment(self):
    """Analyze crypto market sentiment from multiple sources"""
    
    sentiment_prompt = """
    Analyze current cryptocurrency market sentiment based on these factors:
    
    Fear & Greed Index: Research current levels
    Social Media Metrics: Twitter/X mentions, Reddit activity
    Institutional Activity: ETF flows, corporate adoption
    Regulatory Environment: Recent policy developments
    Macro Factors: Interest rates, inflation, global liquidity
    
    Rate sentiment on scale 1-10 where:
    1-3: Extreme Fear (Accumulation phase)
    4-6: Neutral (Trending phase)  
    7-8: Greed (Late bull market)
    9-10: Extreme Greed (Peak warning)
    
    Provide specific evidence for your sentiment score.
    """
    
    response = self.client.chat(
        model='mistral:7b',
        messages=[{'role': 'user', 'content': sentiment_prompt}]
    )
    
    return response['message']['content']

def detect_peak_signals(self):
    """Detect bull market peak signals across timeframes"""
    
    signals = {
        'daily': self._analyze_daily_signals(),
        'weekly': self._analyze_weekly_signals(),
        'monthly': self._analyze_monthly_signals()
    }
    
    # Combine signals with AI analysis
    combined_analysis = self._synthesize_signals(signals)
    
    return combined_analysis

def _analyze_daily_signals(self):
    """Analyze daily timeframe signals"""
    df = self.indicators
    latest = df.iloc[-1]
    
    signals = []
    
    # RSI divergence check
    if latest['RSI'] > 70:
        signals.append({
            'signal': 'RSI_WARNING',
            'value': latest['RSI'],
            'threshold': 80,
            'description': 'RSI approaching overbought territory'
        })
    
    # Volume analysis
    recent_volume = df['Volume'].tail(7).mean()
    historical_volume = df['Volume'].rolling(window=50).mean().iloc[-1]
    
    if recent_volume > historical_volume * 1.5:
        signals.append({
            'signal': 'VOLUME_SPIKE',
            'value': recent_volume / historical_volume,
            'threshold': 2.0,
            'description': 'Unusual volume activity detected'
        })
    
    return signals

def _synthesize_signals(self, signals):
    """Use AI to synthesize multi-timeframe signals"""
    
    synthesis_prompt = f"""
    Cryptocurrency Bull Market Peak Analysis
    
    Signal Data:
    {json.dumps(signals, indent=2)}
    
    Your task:
    1. Weight each signal's importance (1-10 scale)
    2. Calculate overall peak probability (0-100%)
    3. Identify confluence of signals
    4. Predict timeline to potential peak
    5. Recommend specific actions
    
    Peak Probability Scale:
    0-20%: Early bull market, accumulate
    21-40%: Mid bull market, hold and add
    41-60%: Late bull market, reduce risk
    61-80%: Peak approaching, take profits
    81-100%: Peak imminent, exit positions
    
    Provide actionable analysis with specific reasoning.
    """
    
    response = self.client.chat(
        model='llama3.1:70b',
        messages=[{'role': 'user', 'content': synthesis_prompt}]
    )
    
    return response['message']['content']

def project_bitcoin_price(self, target_date="2025-03-31"):
    """Project Bitcoin price using Monte Carlo simulation"""
    
    # Historical volatility analysis
    returns = self.btc_data['Close'].pct_change().dropna()
    daily_vol = returns.std()
    annual_vol = daily_vol * np.sqrt(365)
    
    # Monte Carlo parameters
    current_price = self.btc_data['Close'].iloc[-1]
    days_to_target = (pd.to_datetime(target_date) - pd.to_datetime('today')).days
    
    # Run simulation
    num_simulations = 10000
    price_paths = []
    
    for _ in range(num_simulations):
        prices = [current_price]
        for day in range(days_to_target):
            random_return = np.random.normal(0, daily_vol)
            new_price = prices[-1] * (1 + random_return)
            prices.append(new_price)
        price_paths.append(prices[-1])
    
    # Analyze results
    price_paths = np.array(price_paths)
    target_probability = np.sum(price_paths >= 180000) / num_simulations
    
    projection_data = {
        'current_price': current_price,
        'target_price': 180000,
        'target_date': target_date,
        'probability_180k': target_probability,
        'median_projection': np.median(price_paths),
        'percentile_90': np.percentile(price_paths, 90),
        'percentile_10': np.percentile(price_paths, 10)
    }
    
    return projection_data

def analyze_price_targets(self):
    """Analyze Bitcoin price targets with AI reasoning"""
    
    projection = self.project_bitcoin_price()
    
    analysis_prompt = f"""
    Bitcoin Price Target Analysis for Q1 2025
    
    Current Data:
    - Current Price: ${projection['current_price']:,.2f}
    - Target: $180,000
    - Monte Carlo Probability: {projection['probability_180k']:.1%}
    - Median Projection: ${projection['median_projection']:,.2f}
    
    Historical Context:
    - 2017 Peak: ~$20K (20x from previous cycle low)
    - 2021 Peak: ~$69K (3.5x from previous peak)
    - Current cycle started from ~$15K low
    
    Fundamental Drivers:
    - Bitcoin ETF adoption
    - Corporate treasury allocation
    - Institutional infrastructure development
    - Regulatory clarity improvements
    - Monetary debasement trends
    
    Analysis Requirements:
    1. Evaluate $180K target feasibility
    2. Identify required market conditions
    3. Calculate timeline probabilities
    4. Assess risk/reward scenarios
    5. Compare to historical precedents
    
    Provide detailed reasoning with specific catalysts needed for target achievement.
    """
    
    response = self.client.chat(
        model='llama3.1:70b',
        messages=[{'role': 'user', 'content': analysis_prompt}]
    )
    
    return response['message']['content']

def run_complete_analysis(self):
    """Execute comprehensive bull market analysis"""
    
    print("🚀 Crypto Bull Market Peak Predictor - Starting Analysis...")
    
    # Step 1: Data Collection
    print("\n📊 Fetching Bitcoin market data...")
    self.fetch_bitcoin_data(period="5y")
    
    # Step 2: Technical Analysis
    print("🔍 Calculating technical indicators...")
    self.calculate_technical_indicators()
    
    # Step 3: AI Market Analysis
    print("🤖 Running AI market phase analysis...")
    market_analysis = self.analyze_bull_market_phase()
    
    # Step 4: Sentiment Analysis
    print("📰 Analyzing market sentiment...")
    sentiment_analysis = self.analyze_market_sentiment()
    
    # Step 5: Peak Detection
    print("⚠️ Detecting peak signals...")
    peak_signals = self.detect_peak_signals()
    
    # Step 6: Price Projections
    print("📈 Projecting price targets...")
    price_analysis = self.analyze_price_targets()
    
    # Compile final report
    report = {
        'timestamp': datetime.now().isoformat(),
        'market_analysis': market_analysis,
        'sentiment_analysis': sentiment_analysis,
        'peak_signals': peak_signals,
        'price_analysis': price_analysis,
        'current_price': self.btc_data['Close'].iloc[-1]
    }
    
    return report

# Usage Example
if __name__ == "__main__":
    predictor = CryptoBullMarketPredictor()
    analysis_report = predictor.run_complete_analysis()
    
    # Save report
    with open(f'btc_analysis_{datetime.now().strftime("%Y%m%d")}.json', 'w') as f:
        json.dump(analysis_report, f, indent=2, default=str)
    
    print("✅ Analysis complete! Report saved.")

# Aggressive accumulation strategy
allocation = {
    'bitcoin': 0.6,
    'altcoins': 0.3,
    'cash': 0.1
}

# Balanced growth strategy  
allocation = {
    'bitcoin': 0.5,
    'altcoins': 0.3,
    'cash': 0.2
}

# Risk reduction strategy
allocation = {
    'bitcoin': 0.3,
    'altcoins': 0.2,
    'cash': 0.5
}

def ensemble_prediction(self):
    """Combine multiple AI models for robust predictions"""
    
    models = ['llama3.1:70b', 'mistral:7b', 'codellama:34b']
    predictions = []
    
    for model in models:
        response = self.client.chat(
            model=model,
            messages=[{'role': 'user', 'content': self.get_prediction_prompt()}]
        )
        predictions.append(response['message']['content'])
    
    # Synthesize ensemble result
    ensemble_prompt = f"""
    Cryptocurrency Ensemble Analysis
    
    Model Predictions:
    {json.dumps(predictions, indent=2)}
    
    Create consensus prediction by:
    1. Identifying agreement points
    2. Weighing conflicting predictions  
    3. Calculating confidence intervals
    4. Providing final recommendation
    
    Output structured JSON with reasoning.
    """
    
    final_response = self.client.chat(
        model='llama3.1:70b',
        messages=[{'role': 'user', 'content': ensemble_prompt}]
    )
    
    return final_response['message']['content']

import time
import smtplib
from email.mime.text import MIMEText

class PeakAlertSystem:
    def __init__(self, predictor):
        self.predictor = predictor
        self.alert_thresholds = {
            'peak_probability': 0.75,
            'rsi': 85,
            'mvrv_zscore': 8
        }
    
    def monitor_market(self, check_interval=3600):
        """Monitor market conditions and send alerts"""
        
        while True:
            try:
                # Run analysis
                analysis = self.predictor.run_complete_analysis()
                
                # Check alert conditions
                if self._should_alert(analysis):
                    self._send_alert(analysis)
                
                time.sleep(check_interval)  # Check every hour
                
            except Exception as e:
                print(f"Monitoring error: {e}")
                time.sleep(300)  # Wait 5 minutes before retry
    
    def _should_alert(self, analysis):
        """Determine if alert conditions are met"""
        # Implement your alert logic here
        return False  # Placeholder
    
    def _send_alert(self, analysis):
        """Send alert notification"""
        # Implement email/SMS alert system
        pass

# Use vectorized operations for large datasets
def optimize_calculations(self):
    """Optimize indicator calculations for speed"""
    
    # Vectorized RSI calculation
    def fast_rsi(prices, period=14):
        delta = prices.diff()
        gain = np.where(delta > 0, delta, 0)
        loss = np.where(delta < 0, -delta, 0)
        
        avg_gain = pd.Series(gain).rolling(window=period).mean()
        avg_loss = pd.Series(loss).rolling(window=period).mean()
        
        rs = avg_gain / avg_loss
        rsi = 100 - (100 / (1 + rs))
        
        return rsi
    
    # Parallel processing for multiple timeframes
    from concurrent.futures import ThreadPoolExecutor
    
    def parallel_analysis(self):
        with ThreadPoolExecutor(max_workers=4) as executor:
            futures = [
                executor.submit(self._analyze_daily_signals),
                executor.submit(self._analyze_weekly_signals), 
                executor.submit(self._analyze_monthly_signals),
                executor.submit(self.analyze_market_sentiment)
            ]
            
            results = [future.result() for future in futures]
            return results

FROM python:3.11-slim

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

# Copy application files
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . /app
WORKDIR /app

# Download models
RUN ollama pull llama3.1:70b
RUN ollama pull mistral:7b

# Start application
CMD ["python", "crypto_predictor.py"]

def generate_daily_report(self):
    """Generate automated daily analysis report"""
    
    analysis = self.run_complete_analysis()
    
    # Create HTML report
    html_template = """
    <!DOCTYPE html>
    <html>
    <head>
        <title>Bitcoin Bull Market Analysis - {date}</title>
        <style>
            body {{ font-family: Arial, sans-serif; margin: 40px; }}
            .alert {{ background: #ff6b6b; color: white; padding: 15px; }}
            .warning {{ background: #feca57; padding: 15px; }}
            .safe {{ background: #48dbfb; padding: 15px; }}
        </style>
    </head>
    <body>
        <h1>🚀 Bitcoin Bull Market Analysis</h1>
        <h2>Current Price: ${current_price:,.2f}</h2>
        
        <div class="{alert_class}">
            <h3>Market Phase: {market_phase}</h3>
            <p>Peak Probability: {peak_probability}%</p>
        </div>
        
        <h3>Key Indicators</h3>
        <ul>
            <li>RSI: {rsi:.1f}</li>
            <li>MVRV Z-Score: {mvrv:.2f}</li>
            <li>$180K Probability: {target_prob:.1%}</li>
        </ul>
        
        <h3>Recommended Actions</h3>
        <p>{recommendations}</p>
        
        <small>Generated by Ollama Crypto Bull Market Predictor</small>
    </body>
    </html>
    """
    
    # Format report with analysis data
    formatted_report = html_template.format(
        date=datetime.now().strftime("%Y-%m-%d"),
        current_price=analysis['current_price'],
        alert_class="alert",  # Dynamic based on risk level
        market_phase="Late Bull Market",  # From AI analysis
        peak_probability=75,  # From AI analysis
        rsi=82.5,  # From technical analysis
        mvrv=7.2,  # From technical analysis  
        target_prob=0.65,  # From Monte Carlo
        recommendations="Reduce risk. Take profits on 30% of holdings."
    )
    
    return formatted_report