Corporate Bitcoin Allocation Strategy: Using Ollama for Optimal Portfolio Analysis

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

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

# requirements.txt
ollama-python==0.1.7
pandas==2.0.3
numpy==1.24.3
matplotlib==3.7.1
yfinance==0.2.18
requests==2.31.0

pip install -r requirements.txt

import ollama
import pandas as pd
import numpy as np
import yfinance as yf
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

class BitcoinAllocationAnalyzer:
    def __init__(self):
        self.client = ollama.Client()
        self.btc_data = None
        self.company_data = None
        
    def fetch_market_data(self, symbol="BTC-USD", period="2y"):
        """Fetch Bitcoin price data for analysis"""
        try:
            ticker = yf.Ticker(symbol)
            data = ticker.history(period=period)
            self.btc_data = data
            return data
        except Exception as e:
            print(f"Error fetching data: {e}")
            return None
    
    def calculate_volatility_metrics(self):
        """Calculate Bitcoin volatility statistics"""
        if self.btc_data is None:
            return None
            
        returns = self.btc_data['Close'].pct_change().dropna()
        
        metrics = {
            'daily_volatility': returns.std(),
            'annualized_volatility': returns.std() * np.sqrt(252),
            'max_drawdown': self.calculate_max_drawdown(),
            'sharpe_ratio': self.calculate_sharpe_ratio(returns),
            'var_95': np.percentile(returns, 5),
            'var_99': np.percentile(returns, 1)
        }
        
        return metrics
    
    def calculate_max_drawdown(self):
        """Calculate maximum drawdown period"""
        prices = self.btc_data['Close']
        cumulative = (1 + prices.pct_change()).cumprod()
        running_max = cumulative.expanding().max()
        drawdown = (cumulative - running_max) / running_max
        return drawdown.min()
    
    def calculate_sharpe_ratio(self, returns, risk_free_rate=0.02):
        """Calculate risk-adjusted returns"""
        excess_return = returns.mean() * 252 - risk_free_rate
        volatility = returns.std() * np.sqrt(252)
        return excess_return / volatility if volatility != 0 else 0

def analyze_allocation_scenario(self, allocation_percent, company_cash):
    """Use Ollama to analyze allocation scenarios"""
    
    # Prepare context for AI analysis
    metrics = self.calculate_volatility_metrics()
    btc_allocation = company_cash * (allocation_percent / 100)
    
    prompt = f"""
    Analyze this corporate Bitcoin allocation scenario:
    
    Company Cash: ${company_cash:,.0f}
    Bitcoin Allocation: {allocation_percent}% (${btc_allocation:,.0f})
    
    Bitcoin Metrics:
    - Annual Volatility: {metrics['annualized_volatility']:.2%}
    - Maximum Drawdown: {metrics['max_drawdown']:.2%}
    - Sharpe Ratio: {metrics['sharpe_ratio']:.2f}
    - 95% VaR: {metrics['var_95']:.2%}
    
    Provide analysis covering:
    1. Risk assessment for this allocation level
    2. Potential impact on balance sheet stability
    3. Liquidity considerations
    4. Regulatory compliance factors
    5. Recommended risk management strategies
    
    Focus on practical corporate treasury management.
    """
    
    try:
        response = self.client.generate(
            model='llama2:13b',
            prompt=prompt,
            options={'temperature': 0.3, 'top_p': 0.9}
        )
        return response['response']
    except Exception as e:
        return f"Analysis error: {e}"

def compare_allocation_scenarios(self, scenarios, company_cash):
    """Compare multiple allocation percentages"""
    
    results = {}
    
    for allocation in scenarios:
        btc_amount = company_cash * (allocation / 100)
        
        # Calculate scenario metrics
        scenario_data = {
            'allocation_percent': allocation,
            'btc_amount': btc_amount,
            'cash_remaining': company_cash - btc_amount,
            'analysis': self.analyze_allocation_scenario(allocation, company_cash)
        }
        
        results[f"{allocation}%"] = scenario_data
    
    return results

def run_monte_carlo_simulation(self, allocation_percent, company_cash, 
                              days=252, simulations=1000):
    """Simulate portfolio value over time"""
    
    if self.btc_data is None:
        return None
    
    # Calculate Bitcoin return statistics
    returns = self.btc_data['Close'].pct_change().dropna()
    mean_return = returns.mean()
    volatility = returns.std()
    
    # Portfolio allocation
    btc_allocation = company_cash * (allocation_percent / 100)
    cash_allocation = company_cash - btc_allocation
    
    # Run simulations
    simulation_results = []
    
    for _ in range(simulations):
        # Generate random Bitcoin returns
        random_returns = np.random.normal(mean_return, volatility, days)
        
        # Calculate portfolio values
        btc_values = [btc_allocation]
        for return_rate in random_returns:
            new_value = btc_values[-1] * (1 + return_rate)
            btc_values.append(new_value)
        
        # Total portfolio value (cash + Bitcoin)
        portfolio_values = [cash_allocation + btc_val for btc_val in btc_values]
        simulation_results.append(portfolio_values)
    
    return np.array(simulation_results)

def analyze_simulation_results(self, simulation_results, company_cash):
    """Extract insights from Monte Carlo results"""
    
    final_values = simulation_results[:, -1]
    
    analysis = {
        'mean_final_value': np.mean(final_values),
        'median_final_value': np.median(final_values),
        'std_final_value': np.std(final_values),
        'min_final_value': np.min(final_values),
        'max_final_value': np.max(final_values),
        'prob_loss': np.mean(final_values < company_cash),
        'prob_gain_10': np.mean(final_values > company_cash * 1.1),
        'prob_gain_25': np.mean(final_values > company_cash * 1.25),
        'var_95': np.percentile(final_values, 5),
        'var_99': np.percentile(final_values, 1)
    }
    
    return analysis

def create_allocation_dashboard(self, scenarios, company_cash):
    """Generate visual analysis dashboard"""
    
    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
    fig.suptitle('Corporate Bitcoin Allocation Analysis Dashboard', 
                 fontsize=16, fontweight='bold')
    
    # Scenario comparison
    allocations = []
    expected_returns = []
    risk_metrics = []
    
    for scenario in scenarios:
        sim_results = self.run_monte_carlo_simulation(scenario, company_cash)
        analysis = self.analyze_simulation_results(sim_results, company_cash)
        
        allocations.append(scenario)
        expected_returns.append(analysis['mean_final_value'] / company_cash - 1)
        risk_metrics.append(analysis['std_final_value'] / company_cash)
    
    # Risk-Return Plot
    axes[0, 0].scatter(risk_metrics, expected_returns, s=100, alpha=0.7)
    for i, alloc in enumerate(allocations):
        axes[0, 0].annotate(f'{alloc}%', 
                           (risk_metrics[i], expected_returns[i]),
                           xytext=(5, 5), textcoords='offset points')
    axes[0, 0].set_xlabel('Risk (Portfolio Volatility)')
    axes[0, 0].set_ylabel('Expected Return')
    axes[0, 0].set_title('Risk-Return Profile by Allocation')
    axes[0, 0].grid(True, alpha=0.3)
    
    # Bitcoin Price History
    if self.btc_data is not None:
        axes[0, 1].plot(self.btc_data.index, self.btc_data['Close'])
        axes[0, 1].set_title('Bitcoin Price History')
        axes[0, 1].set_ylabel('Price (USD)')
        axes[0, 1].grid(True, alpha=0.3)
    
    # Probability Analysis
    prob_loss = [self.analyze_simulation_results(
        self.run_monte_carlo_simulation(alloc, company_cash), 
        company_cash)['prob_loss'] for alloc in allocations]
    
    axes[1, 0].bar(allocations, prob_loss, alpha=0.7, color='red')
    axes[1, 0].set_xlabel('Bitcoin Allocation (%)')
    axes[1, 0].set_ylabel('Probability of Loss')
    axes[1, 0].set_title('Risk of Loss by Allocation Level')
    axes[1, 0].grid(True, alpha=0.3)
    
    # Value at Risk
    var_95 = [self.analyze_simulation_results(
        self.run_monte_carlo_simulation(alloc, company_cash), 
        company_cash)['var_95'] / company_cash - 1 for alloc in allocations]
    
    axes[1, 1].bar(allocations, var_95, alpha=0.7, color='orange')
    axes[1, 1].set_xlabel('Bitcoin Allocation (%)')
    axes[1, 1].set_ylabel('95% VaR')
    axes[1, 1].set_title('Value at Risk (95% Confidence)')
    axes[1, 1].grid(True, alpha=0.3)
    
    plt.tight_layout()
    return fig

# Initialize analyzer
analyzer = BitcoinAllocationAnalyzer()

# Fetch current market data
print("Fetching Bitcoin market data...")
btc_data = analyzer.fetch_market_data()

# Company parameters
company_cash = 100_000_000  # $100M treasury
allocation_scenarios = [1, 2, 5, 10, 15, 20]  # Test percentages

# Run comprehensive analysis
print("Analyzing allocation scenarios...")
scenario_results = analyzer.compare_allocation_scenarios(
    allocation_scenarios, company_cash
)

# Generate detailed report for each scenario
for scenario, data in scenario_results.items():
    print(f"\n{'='*50}")
    print(f"SCENARIO: {scenario} Bitcoin Allocation")
    print(f"{'='*50}")
    print(f"Bitcoin Amount: ${data['btc_amount']:,.0f}")
    print(f"Cash Remaining: ${data['cash_remaining']:,.0f}")
    print(f"\nAI Analysis:")
    print(data['analysis'])
    
    # Run Monte Carlo simulation
    sim_results = analyzer.run_monte_carlo_simulation(
        data['allocation_percent'], company_cash
    )
    sim_analysis = analyzer.analyze_simulation_results(sim_results, company_cash)
    
    print(f"\nSimulation Results (1-year projection):")
    print(f"Expected Value: ${sim_analysis['mean_final_value']:,.0f}")
    print(f"Probability of Loss: {sim_analysis['prob_loss']:.1%}")
    print(f"95% Value at Risk: ${sim_analysis['var_95']:,.0f}")

# Create visualization dashboard
dashboard = analyzer.create_allocation_dashboard(allocation_scenarios, company_cash)
dashboard.savefig('bitcoin_allocation_analysis.png', dpi=300, bbox_inches='tight')
print("\nDashboard saved as 'bitcoin_allocation_analysis.png'")

def create_dynamic_allocation_strategy(self, volatility_threshold=0.6):
    """Adjust allocation based on market volatility"""
    
    current_vol = self.calculate_volatility_metrics()['annualized_volatility']
    
    # Base allocation matrix
    allocation_matrix = {
        'low_vol': {'btc': 15, 'reasoning': 'Stable market conditions'},
        'medium_vol': {'btc': 10, 'reasoning': 'Moderate volatility'},
        'high_vol': {'btc': 5, 'reasoning': 'High volatility protection'}
    }
    
    # Determine allocation based on volatility
    if current_vol < 0.4:
        strategy = allocation_matrix['low_vol']
    elif current_vol < volatility_threshold:
        strategy = allocation_matrix['medium_vol']
    else:
        strategy = allocation_matrix['high_vol']
    
    prompt = f"""
    Given current Bitcoin volatility of {current_vol:.1%}, 
    recommend a dynamic allocation strategy.
    
    Suggested allocation: {strategy['btc']}%
    Reasoning: {strategy['reasoning']}
    
    Provide:
    1. Validation of this allocation level
    2. Trigger points for rebalancing
    3. Emergency liquidity protocols
    4. Board reporting requirements
    """
    
    ai_response = self.client.generate(
        model='llama2:13b',
        prompt=prompt,
        options={'temperature': 0.2}
    )
    
    return {
        'recommended_allocation': strategy['btc'],
        'current_volatility': current_vol,
        'strategy_reasoning': strategy['reasoning'],
        'ai_analysis': ai_response['response']
    }

def generate_board_report(self, allocation_percent, company_cash):
    """Create executive summary for board presentation"""
    
    metrics = self.calculate_volatility_metrics()
    simulation = self.run_monte_carlo_simulation(allocation_percent, company_cash)
    analysis = self.analyze_simulation_results(simulation, company_cash)
    
    prompt = f"""
    Create an executive summary for board presentation:
    
    PROPOSED BITCOIN ALLOCATION
    Allocation: {allocation_percent}% of treasury (${company_cash * allocation_percent/100:,.0f})
    
    RISK METRICS
    - Expected Annual Return: {(analysis['mean_final_value']/company_cash - 1)*100:.1f}%
    - Probability of Loss: {analysis['prob_loss']:.1%}
    - 95% Value at Risk: ${analysis['var_95']:,.0f}
    - Maximum Historical Drawdown: {metrics['max_drawdown']:.1%}
    
    Provide:
    1. Strategic rationale (2-3 sentences)
    2. Key risks and mitigation strategies
    3. Impact on financial statements
    4. Regulatory considerations
    5. Implementation timeline
    6. Success metrics and review schedule
    
    Keep language appropriate for C-suite executives.
    """
    
    response = self.client.generate(
        model='llama2:13b',
        prompt=prompt,
        options={'temperature': 0.1}
    )
    
    return response['response']