Crypto Winter Survival Guide: Ollama Bear Market Portfolio Protection

# Install Ollama (if not already installed)
curl -fsSL https://ollama.ai/install.sh | sh

# Pull essential models for financial analysis
ollama pull llama2:13b
ollama pull codellama:13b
ollama pull mistral:7b

import requests
import json
import subprocess
from datetime import datetime, timedelta

class OllamaCryptoAnalyzer:
    def __init__(self):
        self.base_url = "http://localhost:11434"
        
    def analyze_portfolio(self, holdings, market_data):
        """
        Analyze portfolio composition and risk using Ollama
        """
        prompt = f"""
        Analyze this crypto portfolio for bear market protection:
        
        Holdings: {json.dumps(holdings, indent=2)}
        Market Data: {json.dumps(market_data, indent=2)}
        
        Provide:
        1. Risk assessment (1-10 scale)
        2. Diversification score
        3. Recommended actions
        4. DCA targets for next 30 days
        
        Focus on capital preservation and strategic accumulation.
        """
        
        response = requests.post(
            f"{self.base_url}/api/generate",
            json={
                "model": "llama2:13b",
                "prompt": prompt,
                "stream": False
            }
        )
        
        return response.json()['response']

# Example usage
analyzer = OllamaCryptoAnalyzer()

# Sample portfolio data
portfolio = {
    "BTC": {"amount": 0.5, "avg_cost": 45000, "current_price": 30000},
    "ETH": {"amount": 2.0, "avg_cost": 3000, "current_price": 1800},
    "SOL": {"amount": 50, "avg_cost": 80, "current_price": 45}
}

market_context = {
    "fear_greed_index": 25,
    "btc_dominance": 52.3,
    "total_market_cap": "1.2T",
    "trend": "bearish"
}

analysis = analyzer.analyze_portfolio(portfolio, market_context)
print(analysis)

class SmartDCAManager:
    def __init__(self, monthly_budget=1000):
        self.monthly_budget = monthly_budget
        self.analyzer = OllamaCryptoAnalyzer()
        
    def calculate_weekly_allocation(self, market_conditions):
        """
        Use Ollama to determine optimal weekly DCA allocation
        """
        prompt = f"""
        Given monthly DCA budget of ${self.monthly_budget}:
        
        Current market conditions:
        - Fear & Greed Index: {market_conditions['fear_greed']}
        - BTC Price: ${market_conditions['btc_price']}
        - Market trend: {market_conditions['trend']}
        - Volume: {market_conditions['volume']}
        
        Calculate optimal weekly allocation:
        1. BTC percentage (30-70%)
        2. ETH percentage (20-40%) 
        3. Alt allocation (0-20%)
        4. Cash reserve (10-30%)
        
        Justify each allocation based on current market fear and technical indicators.
        Return as JSON format.
        """
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "mistral:7b",
                "prompt": prompt,
                "stream": False
            }
        )
        
        return self._parse_allocation_response(response.json()['response'])
    
    def _parse_allocation_response(self, response_text):
        """
        Extract JSON allocation from Ollama response
        """
        try:
            # Find JSON in response
            start = response_text.find('{')
            end = response_text.rfind('}') + 1
            json_str = response_text[start:end]
            return json.loads(json_str)
        except:
            # Fallback conservative allocation
            return {
                "BTC": 50,
                "ETH": 30,
                "alts": 0,
                "cash": 20
            }

# Implementation example
dca_manager = SmartDCAManager(monthly_budget=2000)

current_conditions = {
    "fear_greed": 20,  # Extreme fear
    "btc_price": 28000,
    "trend": "strong_bearish",
    "volume": "below_average"
}

weekly_plan = dca_manager.calculate_weekly_allocation(current_conditions)
print(f"This week's DCA allocation: {weekly_plan}")

class RiskManager:
    def __init__(self, risk_tolerance="moderate"):
        self.risk_tolerance = risk_tolerance
        self.analyzer = OllamaCryptoAnalyzer()
        
    def assess_portfolio_risk(self, portfolio, market_data):
        """
        Comprehensive risk analysis using multiple Ollama models
        """
        # Technical analysis prompt
        technical_prompt = f"""
        Technical Analysis Request:
        
        Portfolio: {json.dumps(portfolio)}
        Market Data: {market_data}
        Risk Tolerance: {self.risk_tolerance}
        
        Analyze:
        1. Correlation risk between holdings
        2. Concentration risk (any position >40%)
        3. Market cap distribution risk
        4. Volatility exposure
        
        Rate overall portfolio risk 1-10 and suggest specific actions.
        """
        
        # Get technical analysis
        tech_response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "codellama:13b",
                "prompt": technical_prompt,
                "stream": False
            }
        )
        
        # Fundamental analysis prompt  
        fundamental_prompt = f"""
        Fundamental Analysis for Bear Market:
        
        Current portfolio risk score: {self._extract_risk_score(tech_response.json()['response'])}
        Holdings breakdown: {self._format_holdings(portfolio)}
        
        For crypto winter survival:
        1. Which projects have strongest fundamentals?
        2. What's the optimal BTC/ETH allocation ratio?
        3. Should we reduce altcoin exposure?
        4. Emergency stop-loss levels?
        
        Provide clear action items with reasoning.
        """
        
        fund_response = requests.post(
            "http://localhost:11434/api/generate", 
            json={
                "model": "llama2:13b",
                "prompt": fundamental_prompt,
                "stream": False
            }
        )
        
        return {
            "technical_analysis": tech_response.json()['response'],
            "fundamental_analysis": fund_response.json()['response'],
            "combined_risk_score": self._calculate_combined_risk(
                tech_response.json()['response'],
                fund_response.json()['response']
            )
        }
    
    def _extract_risk_score(self, analysis_text):
        """Extract numerical risk score from Ollama response"""
        # Simple regex to find "risk: X/10" patterns
        import re
        match = re.search(r'risk.*?(\d+)', analysis_text.lower())
        return int(match.group(1)) if match else 5
        
    def _format_holdings(self, portfolio):
        """Format portfolio for clear analysis"""
        total_value = sum(holding['amount'] * holding['current_price'] 
                         for holding in portfolio.values())
        
        formatted = {}
        for coin, data in portfolio.items():
            value = data['amount'] * data['current_price']
            percentage = (value / total_value) * 100
            formatted[coin] = {
                "percentage": round(percentage, 1),
                "value_usd": round(value, 2),
                "unrealized_pnl": round(
                    (data['current_price'] - data['avg_cost']) / data['avg_cost'] * 100, 1
                )
            }
        return formatted
    
    def _calculate_combined_risk(self, tech_analysis, fund_analysis):
        """Combine technical and fundamental risk scores"""
        tech_score = self._extract_risk_score(tech_analysis)
        fund_score = self._extract_risk_score(fund_analysis)
        return round((tech_score + fund_score) / 2, 1)

# Usage example
risk_manager = RiskManager(risk_tolerance="aggressive")
risk_assessment = risk_manager.assess_portfolio_risk(portfolio, market_context)

print(f"Combined Risk Score: {risk_assessment['combined_risk_score']}/10")
print("\nRecommended Actions:")
print(risk_assessment['fundamental_analysis'])

class SentimentAnalyzer:
    def __init__(self):
        self.analyzer = OllamaCryptoAnalyzer()
        
    def analyze_market_sentiment(self, news_data, social_data, on_chain_data):
        """
        Multi-source sentiment analysis for market timing
        """
        sentiment_prompt = f"""
        Crypto Market Sentiment Analysis:
        
        News Headlines (last 24h): {news_data}
        Social Media Indicators: {social_data}
        On-chain Metrics: {on_chain_data}
        
        Determine:
        1. Overall sentiment score (-100 to +100)
        2. Reliability of sentiment (high/medium/low)
        3. Contrarian opportunities (sentiment vs price)
        4. Optimal entry/exit timing
        
        Focus on actionable insights for bear market navigation.
        """
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "llama2:13b",
                "prompt": sentiment_prompt,
                "stream": False
            }
        )
        
        return self._parse_sentiment_response(response.json()['response'])
    
    def _parse_sentiment_response(self, response_text):
        """Parse sentiment analysis into actionable data"""
        import re
        
        # Extract sentiment score
        score_match = re.search(r'sentiment.*?(-?\d+)', response_text.lower())
        sentiment_score = int(score_match.group(1)) if score_match else 0
        
        # Extract reliability
        reliability = "medium"  # Default
        if "high reliability" in response_text.lower():
            reliability = "high"
        elif "low reliability" in response_text.lower():
            reliability = "low"
            
        return {
            "sentiment_score": sentiment_score,
            "reliability": reliability,
            "analysis": response_text,
            "action": self._determine_action(sentiment_score, reliability)
        }
    
    def _determine_action(self, score, reliability):
        """Convert sentiment to actionable strategy"""
        if score < -60 and reliability == "high":
            return "ACCUMULATE - Extreme fear, likely oversold"
        elif score < -30:
            return "DCA - Negative sentiment, good entry levels"
        elif score > 60:
            return "REDUCE - Euphoria, consider taking profits"
        else:
            return "HOLD - Neutral sentiment, maintain position"

# Example implementation
sentiment_analyzer = SentimentAnalyzer()

sample_data = {
    "news": ["Bitcoin regulation uncertainty", "Major exchange hack", "Institutional adoption news"],
    "social": {"fear_greed": 15, "social_volume": "high", "mentions_trend": "negative"},
    "onchain": {"exchange_inflows": "increasing", "long_term_holders": "accumulating"}
}

sentiment_result = sentiment_analyzer.analyze_market_sentiment(
    sample_data["news"], 
    sample_data["social"], 
    sample_data["onchain"]
)

print(f"Market Sentiment: {sentiment_result['sentiment_score']}/100")
print(f"Recommended Action: {sentiment_result['action']}")

class CryptoWinterDashboard:
    def __init__(self, portfolio, budget):
        self.portfolio = portfolio
        self.monthly_budget = budget
        self.risk_manager = RiskManager()
        self.dca_manager = SmartDCAManager(budget)
        self.sentiment_analyzer = SentimentAnalyzer()
        
    def generate_daily_report(self):
        """
        Generate comprehensive daily analysis report
        """
        # Fetch current market data
        market_data = self._fetch_market_data()
        
        # Run all analyses
        risk_analysis = self.risk_manager.assess_portfolio_risk(
            self.portfolio, market_data
        )
        
        dca_allocation = self.dca_manager.calculate_weekly_allocation(
            market_data
        )
        
        sentiment_analysis = self.sentiment_analyzer.analyze_market_sentiment(
            market_data.get('news', []),
            market_data.get('social', {}),
            market_data.get('onchain', {})
        )
        
        # Generate summary report using Ollama
        report_prompt = f"""
        Daily Crypto Winter Portfolio Report:
        
        Risk Analysis: {risk_analysis['combined_risk_score']}/10
        DCA Allocation: {dca_allocation}
        Market Sentiment: {sentiment_analysis['sentiment_score']}/100
        Portfolio Performance: {self._calculate_portfolio_performance()}
        
        Generate executive summary with:
        1. Top 3 action items for today
        2. Weekly strategy adjustment
        3. Risk alerts (if any)
        4. Market opportunity assessment
        
        Keep summary under 200 words, actionable and specific.
        """
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "mistral:7b",
                "prompt": report_prompt,
                "stream": False
            }
        )
        
        return {
            "executive_summary": response.json()['response'],
            "risk_score": risk_analysis['combined_risk_score'],
            "sentiment_score": sentiment_analysis['sentiment_score'],
            "recommended_action": sentiment_analysis['action'],
            "dca_plan": dca_allocation,
            "timestamp": datetime.now().isoformat()
        }
    
    def _fetch_market_data(self):
        """Fetch real-time market data (implement with your preferred API)"""
        # Placeholder - integrate with CoinGecko, CoinMarketCap, etc.
        return {
            "fear_greed": 25,
            "btc_price": 28000,
            "trend": "bearish",
            "volume": "below_average",
            "news": ["Fed rate decision pending", "Bitcoin ETF updates"],
            "social": {"fear_greed": 20, "social_volume": "high"},
            "onchain": {"exchange_inflows": "high", "dormant_coins": "moving"}
        }
    
    def _calculate_portfolio_performance(self):
        """Calculate current portfolio metrics"""
        total_invested = sum(
            holding['amount'] * holding['avg_cost'] 
            for holding in self.portfolio.values()
        )
        
        current_value = sum(
            holding['amount'] * holding['current_price']
            for holding in self.portfolio.values()
        )
        
        return {
            "total_invested": total_invested,
            "current_value": current_value,
            "unrealized_pnl": current_value - total_invested,
            "unrealized_pnl_percent": ((current_value - total_invested) / total_invested) * 100
        }

# Initialize dashboard
dashboard = CryptoWinterDashboard(portfolio, monthly_budget=2000)

# Generate daily report
daily_report = dashboard.generate_daily_report()
print("=== CRYPTO WINTER DAILY REPORT ===")
print(f"Risk Score: {daily_report['risk_score']}/10")
print(f"Market Sentiment: {daily_report['sentiment_score']}/100")
print(f"Action: {daily_report['recommended_action']}")
print("\nExecutive Summary:")
print(daily_report['executive_summary'])

class YieldOptimizer:
    def __init__(self):
        self.analyzer = OllamaCryptoAnalyzer()
        
    def analyze_yield_opportunities(self, available_tokens, risk_tolerance):
        """
        Find optimal yield strategies for bear market
        """
        yield_prompt = f"""
        Yield Optimization for Crypto Winter:
        
        Available tokens: {available_tokens}
        Risk tolerance: {risk_tolerance}
        Market condition: Bear market/crypto winter
        
        Analyze and rank yield opportunities:
        1. Staking rewards (native staking)
        2. DeFi lending protocols
        3. Liquidity provision
        4. Yield farming strategies
        
        For each opportunity provide:
        - APY potential
        - Risk assessment (1-10)
        - Impermanent loss risk
        - Platform security score
        - Recommended allocation %
        
        Focus on capital preservation and sustainable yields.
        """
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "llama2:13b", 
                "prompt": yield_prompt,
                "stream": False
            }
        )
        
        return response.json()['response']

# Example usage
yield_optimizer = YieldOptimizer()

available_tokens = {
    "ETH": 1.5,
    "USDC": 5000,
    "SOL": 25,
    "ATOM": 100
}

yield_analysis = yield_optimizer.analyze_yield_opportunities(
    available_tokens, 
    "conservative"
)

print("Yield Optimization Report:")
print(yield_analysis)

class TaxLossHarvester:
    def __init__(self, portfolio, tax_rate=0.25):
        self.portfolio = portfolio
        self.tax_rate = tax_rate
        self.analyzer = OllamaCryptoAnalyzer()
        
    def identify_harvest_opportunities(self):
        """
        Identify tax loss harvesting opportunities
        """
        harvest_prompt = f"""
        Tax Loss Harvesting Analysis:
        
        Portfolio with unrealized losses: {self._calculate_unrealized_losses()}
        Tax rate: {self.tax_rate * 100}%
        Current date: {datetime.now().strftime('%Y-%m-%d')}
        
        Identify optimal tax loss harvesting strategy:
        1. Which positions to harvest now
        2. Wash sale rule considerations  
        3. Rebalancing opportunities
        4. Tax savings estimation
        5. Timing for re-entry
        
        Provide specific action plan with dollar amounts.
        """
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "codellama:13b",
                "prompt": harvest_prompt,
                "stream": False
            }
        )
        
        return response.json()['response']
    
    def _calculate_unrealized_losses(self):
        """Calculate current unrealized losses for each position"""
        losses = {}
        for coin, data in self.portfolio.items():
            current_value = data['amount'] * data['current_price']
            cost_basis = data['amount'] * data['avg_cost']
            unrealized_loss = cost_basis - current_value
            
            if unrealized_loss > 0:
                losses[coin] = {
                    "unrealized_loss": unrealized_loss,
                    "loss_percentage": (unrealized_loss / cost_basis) * 100,
                    "tax_benefit": unrealized_loss * self.tax_rate
                }
        
        return losses

# Usage
tax_harvester = TaxLossHarvester(portfolio, tax_rate=0.30)
harvest_plan = tax_harvester.identify_harvest_opportunities()
print("Tax Loss Harvesting Recommendations:")
print(harvest_plan)

class AlertSystem:
    def __init__(self, notification_channels):
        self.channels = notification_channels  # email, telegram, discord, etc.
        self.analyzer = OllamaCryptoAnalyzer()
        
    def setup_smart_alerts(self, alert_conditions):
        """
        Configure AI-powered alert system
        """
        alert_prompt = f"""
        Smart Alert Configuration:
        
        Alert conditions: {alert_conditions}
        Current portfolio: {self._get_portfolio_summary()}
        
        Design intelligent alert triggers for:
        1. Extreme fear levels (buying opportunities)
        2. Portfolio risk threshold breaches
        3. Major market structure breaks
        4. Yield opportunity alerts
        5. Rebalancing signals
        
        For each trigger, specify:
        - Exact condition
        - Urgency level (1-5)
        - Recommended action
        - Alert frequency limits
        """
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "mistral:7b",
                "prompt": alert_prompt,
                "stream": False
            }
        )
        
        return self._parse_alert_config(response.json()['response'])
    
    def check_alert_conditions(self, current_market_data):
        """
        Check if any alert conditions are triggered
        """
        alerts = []
        
        # Fear & Greed extreme levels
        if current_market_data.get('fear_greed', 50) < 20:
            alerts.append({
                "type": "EXTREME_FEAR",
                "urgency": 4,
                "message": f"Extreme fear detected (F&G: {current_market_data['fear_greed']}). Consider increasing DCA.",
                "action": "Increase weekly DCA by 50%"
            })
        
        # Portfolio risk alerts
        # Add more conditions based on your strategy
        
        return alerts
    
    def _get_portfolio_summary(self):
        """Get simplified portfolio overview"""
        return {coin: {"value": data['amount'] * data['current_price']} 
                for coin, data in self.portfolio.items()}
    
    def _parse_alert_config(self, response_text):
        """Parse Ollama response into alert configuration"""
        # Implementation to extract structured alert config
        return {"alerts_configured": True, "config": response_text}

# Setup alerts
alert_system = AlertSystem(["email", "telegram"])
alert_config = alert_system.setup_smart_alerts({
    "fear_greed_threshold": 25,
    "portfolio_risk_max": 7,
    "btc_drop_percent": 15
})

class PsychologyCoach:
    def __init__(self):
        self.analyzer = OllamaCryptoAnalyzer()
        
    def generate_mindset_report(self, portfolio_performance, market_sentiment):
        """
        Generate psychological guidance for crypto winter
        """
        psychology_prompt = f"""
        Crypto Winter Psychology Coaching:
        
        Portfolio performance: {portfolio_performance}
        Market sentiment: {market_sentiment}
        Market phase: Crypto winter/bear market
        
        Provide psychological guidance covering:
        1. Common emotional traps during bear markets
        2. Reframing portfolio losses as opportunities
        3. Specific mantras for difficult days
        4. Decision-making frameworks to avoid FOMO/panic
        5. Long-term perspective reminders
        
        Keep advice practical, empathetic, and actionable.
        """
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "llama2:13b",
                "prompt": psychology_prompt,
                "stream": False
            }
        )
        
        return response.json()['response']

# Example usage
psychology_coach = PsychologyCoach()
mindset_guidance = psychology_coach.generate_mindset_report(
    portfolio_performance="-45%",
    market_sentiment="extreme_fear"
)

print("Daily Mindset Report:")
print(mindset_guidance)