How to Analyze Bitcoin Treasury Performance with Ollama: MicroStrategy Case Study

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

# Start Ollama service
ollama serve

# Pull required models
ollama pull llama3.1:8b
ollama pull codellama:7b

pip install ollama pandas numpy yfinance requests matplotlib seaborn

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

# Initialize Ollama client
client = ollama.Client()

# Test connection
response = client.chat(model='llama3.1:8b', messages=[
    {'role': 'user', 'content': 'Hello, are you ready to analyze Bitcoin treasury data?'}
])
print(response['message']['content'])

def get_microstrategy_bitcoin_data():
    """
    Compile MicroStrategy's Bitcoin purchase history
    Data from SEC filings and company announcements
    """
    # MicroStrategy Bitcoin purchases (major transactions)
    purchases = [
        {"date": "2020-08-11", "btc_amount": 21454, "usd_amount": 250000000, "avg_price": 11653},
        {"date": "2020-09-15", "btc_amount": 16796, "usd_amount": 175000000, "avg_price": 10419},
        {"date": "2020-12-04", "btc_amount": 2574, "usd_amount": 50000000, "avg_price": 19427},
        {"date": "2021-01-22", "btc_amount": 314, "usd_amount": 10000000, "avg_price": 31808},
        {"date": "2021-02-03", "btc_amount": 295, "usd_amount": 10000000, "avg_price": 33808},
        {"date": "2021-02-24", "btc_amount": 1026, "usd_amount": 52765000, "avg_price": 51413},
        {"date": "2021-03-05", "btc_amount": 328, "usd_amount": 15000000, "avg_price": 45714},
        {"date": "2021-03-24", "btc_amount": 262, "usd_amount": 15000000, "avg_price": 57146},
        {"date": "2021-04-05", "btc_amount": 253, "usd_amount": 15000000, "avg_price": 59339},
        {"date": "2021-05-13", "btc_amount": 229, "usd_amount": 10000000, "avg_price": 43663},
        {"date": "2021-06-21", "btc_amount": 13005, "usd_amount": 489000000, "avg_price": 37617},
        {"date": "2021-08-24", "btc_amount": 3907, "usd_amount": 177000000, "avg_price": 45294},
        {"date": "2021-09-13", "btc_amount": 5050, "usd_amount": 242900000, "avg_price": 48099},
        {"date": "2021-11-29", "btc_amount": 7002, "usd_amount": 414400000, "avg_price": 59187},
        {"date": "2022-03-24", "btc_amount": 4167, "usd_amount": 190500000, "avg_price": 45714},
        {"date": "2022-05-03", "btc_amount": 480, "usd_amount": 25000000, "avg_price": 52083},
        {"date": "2022-06-28", "btc_amount": 480, "usd_amount": 10000000, "avg_price": 20817},
        {"date": "2022-12-22", "btc_amount": 810, "usd_amount": 13500000, "avg_price": 16667},
        {"date": "2023-02-27", "btc_amount": 6455, "usd_amount": 150000000, "avg_price": 23238},
        {"date": "2023-03-23", "btc_amount": 6068, "usd_amount": 174000000, "avg_price": 28646},
        {"date": "2023-04-24", "btc_amount": 1045, "usd_amount": 29700000, "avg_price": 28421},
        {"date": "2023-09-20", "btc_amount": 5445, "usd_amount": 147300000, "avg_price": 27053},
        {"date": "2023-11-01", "btc_amount": 16130, "usd_amount": 593000000, "avg_price": 36759},
        {"date": "2024-01-31", "btc_amount": 3000, "usd_amount": 155400000, "avg_price": 51800},
        {"date": "2024-02-26", "btc_amount": 3000, "usd_amount": 155400000, "avg_price": 51800},
        {"date": "2024-03-11", "btc_amount": 12000, "usd_amount": 821700000, "avg_price": 68475},
    ]
    
    df = pd.DataFrame(purchases)
    df['date'] = pd.to_datetime(df['date'])
    df['cumulative_btc'] = df['btc_amount'].cumsum()
    df['cumulative_usd'] = df['usd_amount'].cumsum()
    df['avg_cost_basis'] = df['cumulative_usd'] / df['cumulative_btc']
    
    return df

# Load the data
mstr_data = get_microstrategy_bitcoin_data()
print("MicroStrategy Bitcoin Treasury Data Loaded")
print(f"Total Bitcoin: {mstr_data['cumulative_btc'].iloc[-1]:,.0f} BTC")
print(f"Total Investment: ${mstr_data['cumulative_usd'].iloc[-1]:,.0f}")

def get_bitcoin_price_data(start_date, end_date):
    """
    Fetch Bitcoin price data from Yahoo Finance
    """
    btc_data = yf.download('BTC-USD', start=start_date, end=end_date)
    return btc_data

# Get Bitcoin price data from first purchase to now
start_date = mstr_data['date'].min()
end_date = datetime.now()

btc_prices = get_bitcoin_price_data(start_date, end_date)
print(f"Bitcoin price data loaded: {len(btc_prices)} days")

def analyze_treasury_performance(purchase_data, price_data, analysis_date=None):
    """
    Comprehensive treasury performance analysis
    """
    if analysis_date is None:
        analysis_date = datetime.now()
    
    # Calculate portfolio value at analysis date
    total_btc = purchase_data['cumulative_btc'].iloc[-1]
    total_invested = purchase_data['cumulative_usd'].iloc[-1]
    avg_cost_basis = total_invested / total_btc
    
    # Get current Bitcoin price
    current_price = price_data.loc[price_data.index <= analysis_date]['Close'].iloc[-1]
    
    # Calculate performance metrics
    current_value = total_btc * current_price
    unrealized_pnl = current_value - total_invested
    roi_percentage = (unrealized_pnl / total_invested) * 100
    
    # Calculate time-weighted returns
    days_held = (analysis_date - purchase_data['date'].min()).days
    annualized_return = ((current_value / total_invested) ** (365/days_held) - 1) * 100
    
    analysis_results = {
        'analysis_date': analysis_date,
        'total_btc_holdings': total_btc,
        'total_invested_usd': total_invested,
        'average_cost_basis': avg_cost_basis,
        'current_btc_price': current_price,
        'current_portfolio_value': current_value,
        'unrealized_pnl': unrealized_pnl,
        'roi_percentage': roi_percentage,
        'days_held': days_held,
        'annualized_return': annualized_return
    }
    
    return analysis_results

# Run the analysis
performance = analyze_treasury_performance(mstr_data, btc_prices)

def generate_treasury_insights(performance_data, model='llama3.1:8b'):
    """
    Use Ollama to generate intelligent treasury analysis insights
    """
    
    # Prepare data for AI analysis
    analysis_prompt = f"""
    Analyze the following Bitcoin treasury performance data for MicroStrategy:
    
    Portfolio Summary:
    - Total Bitcoin Holdings: {performance_data['total_btc_holdings']:,.0f} BTC
    - Total Investment: ${performance_data['total_invested_usd']:,.0f}
    - Average Cost Basis: ${performance_data['average_cost_basis']:,.0f}
    - Current Bitcoin Price: ${performance_data['current_btc_price']:,.0f}
    - Current Portfolio Value: ${performance_data['current_portfolio_value']:,.0f}
    - Unrealized P&L: ${performance_data['unrealized_pnl']:,.0f}
    - ROI Percentage: {performance_data['roi_percentage']:.1f}%
    - Days Held: {performance_data['days_held']} days
    - Annualized Return: {performance_data['annualized_return']:.1f}%
    
    Please provide:
    1. Overall performance assessment
    2. Risk analysis considering Bitcoin volatility
    3. Comparison to traditional treasury investments
    4. Strategic recommendations for similar companies
    5. Key insights about timing and market conditions
    
    Format the response as a comprehensive financial analysis report.
    """
    
    response = client.chat(model=model, messages=[
        {'role': 'user', 'content': analysis_prompt}
    ])
    
    return response['message']['content']

# Generate AI insights
insights = generate_treasury_insights(performance)
print("AI-Generated Treasury Analysis:")
print(insights)

def calculate_portfolio_volatility(price_data, purchase_data):
    """
    Calculate portfolio volatility metrics
    """
    # Calculate daily returns
    daily_returns = price_data['Close'].pct_change().dropna()
    
    # Volatility metrics
    daily_volatility = daily_returns.std()
    annualized_volatility = daily_volatility * np.sqrt(365)
    
    # Value at Risk (VaR) calculations
    total_btc = purchase_data['cumulative_btc'].iloc[-1]
    current_price = price_data['Close'].iloc[-1]
    portfolio_value = total_btc * current_price
    
    # 95% VaR (5% worst case)
    var_95 = np.percentile(daily_returns, 5)
    portfolio_var_95 = portfolio_value * var_95
    
    volatility_data = {
        'daily_volatility': daily_volatility,
        'annualized_volatility': annualized_volatility,
        'portfolio_var_95': portfolio_var_95,
        'portfolio_value': portfolio_value
    }
    
    return volatility_data

def analyze_risk_with_ollama(volatility_data, model='llama3.1:8b'):
    """
    Use Ollama to analyze portfolio risk metrics
    """
    
    risk_prompt = f"""
    Analyze the following Bitcoin treasury risk metrics:
    
    Volatility Analysis:
    - Daily Volatility: {volatility_data['daily_volatility']:.4f} ({volatility_data['daily_volatility']*100:.2f}%)
    - Annualized Volatility: {volatility_data['annualized_volatility']:.4f} ({volatility_data['annualized_volatility']*100:.1f}%)
    - Portfolio Value: ${volatility_data['portfolio_value']:,.0f}
    - 95% Value at Risk (Daily): ${volatility_data['portfolio_var_95']:,.0f}
    
    Provide analysis on:
    1. Risk level assessment compared to traditional assets
    2. Implications for corporate treasury management
    3. Risk mitigation strategies
    4. Liquidity considerations
    5. Regulatory and compliance factors
    
    Focus on practical risk management for corporate treasurers.
    """
    
    response = client.chat(model=model, messages=[
        {'role': 'user', 'content': risk_prompt}
    ])
    
    return response['message']['content']

# Calculate volatility and analyze risk
vol_data = calculate_portfolio_volatility(btc_prices, mstr_data)
risk_analysis = analyze_risk_with_ollama(vol_data)
print("Risk Analysis Results:")
print(risk_analysis)

def run_scenario_analysis(performance_data, scenarios):
    """
    Run multiple price scenarios to test portfolio resilience
    """
    base_value = performance_data['current_portfolio_value']
    total_btc = performance_data['total_btc_holdings']
    current_price = performance_data['current_btc_price']
    
    scenario_results = []
    
    for scenario_name, price_change in scenarios.items():
        new_price = current_price * (1 + price_change)
        new_value = total_btc * new_price
        value_change = new_value - base_value
        percentage_change = (value_change / base_value) * 100
        
        scenario_results.append({
            'scenario': scenario_name,
            'price_change': price_change * 100,
            'new_btc_price': new_price,
            'new_portfolio_value': new_value,
            'value_change': value_change,
            'percentage_change': percentage_change
        })
    
    return pd.DataFrame(scenario_results)

# Define scenarios
scenarios = {
    'Bear Market (-50%)': -0.50,
    'Correction (-30%)': -0.30,
    'Minor Pullback (-20%)': -0.20,
    'Current': 0.00,
    'Bull Run (+50%)': 0.50,
    'Extreme Bull (+100%)': 1.00,
    'Hyperbitcoinization (+500%)': 5.00
}

scenario_results = run_scenario_analysis(performance, scenarios)

def analyze_scenarios_with_ollama(scenario_df, model='llama3.1:8b'):
    """
    Use Ollama to analyze scenario results
    """
    
    scenario_text = scenario_df.to_string(index=False)
    
    scenario_prompt = f"""
    Analyze the following Bitcoin treasury scenario analysis results:
    
    {scenario_text}
    
    Provide insights on:
    1. Portfolio resilience across different market conditions
    2. Downside protection and upside potential
    3. Strategic implications for corporate decision-making
    4. Risk-reward assessment
    5. Recommendations for portfolio management
    
    Focus on actionable insights for treasury management.
    """
    
    response = client.chat(model=model, messages=[
        {'role': 'user', 'content': scenario_prompt}
    ])
    
    return response['message']['content']

scenario_analysis = analyze_scenarios_with_ollama(scenario_results)
print("Scenario Analysis:")
print(scenario_analysis)

def compare_treasury_alternatives(btc_performance, start_date, end_date):
    """
    Compare Bitcoin treasury performance against traditional alternatives
    """
    
    # Fetch traditional asset data
    assets = {
        'SPY': 'S&P 500 ETF',
        'TLT': '20+ Year Treasury Bond ETF',
        'GLD': 'Gold ETF',
        'VMOT': 'Vanguard Ultra-Short-Term Bond ETF'
    }
    
    comparison_data = {}
    investment_amount = btc_performance['total_invested_usd']
    
    for ticker, name in assets.items():
        try:
            asset_data = yf.download(ticker, start=start_date, end=end_date)
            start_price = asset_data['Close'].iloc[0]
            end_price = asset_data['Close'].iloc[-1]
            
            shares_purchased = investment_amount / start_price
            current_value = shares_purchased * end_price
            total_return = ((current_value / investment_amount) - 1) * 100
            
            comparison_data[ticker] = {
                'name': name,
                'start_price': start_price,
                'end_price': end_price,
                'shares_purchased': shares_purchased,
                'current_value': current_value,
                'total_return': total_return
            }
        except Exception as e:
            print(f"Error fetching {ticker}: {e}")
    
    # Add Bitcoin performance
    comparison_data['BTC'] = {
        'name': 'Bitcoin',
        'start_price': btc_performance['average_cost_basis'],
        'end_price': btc_performance['current_btc_price'],
        'shares_purchased': btc_performance['total_btc_holdings'],
        'current_value': btc_performance['current_portfolio_value'],
        'total_return': btc_performance['roi_percentage']
    }
    
    return comparison_data

def generate_comparative_analysis(comparison_data, model='llama3.1:8b'):
    """
    Use Ollama to analyze comparative performance
    """
    
    comparison_text = ""
    for asset, data in comparison_data.items():
        comparison_text += f"""
        {data['name']} ({asset}):
        - Current Value: ${data['current_value']:,.0f}
        - Total Return: {data['total_return']:.1f}%
        """
    
    comparative_prompt = f"""
    Compare MicroStrategy's Bitcoin treasury strategy against traditional alternatives:
    
    {comparison_text}
    
    All investments assume the same ${comparison_data['BTC']['current_value']/comparison_data['BTC']['shares_purchased']*comparison_data['BTC']['shares_purchased']:,.0f} initial investment.
    
    Analyze:
    1. Performance ranking and relative returns
    2. Risk-adjusted performance considerations
    3. Liquidity and operational differences
    4. Strategic advantages and disadvantages of each approach
    5. Suitability for different types of companies
    6. Future outlook and sustainability
    
    Provide balanced analysis considering both returns and risks.
    """
    
    response = client.chat(model=model, messages=[
        {'role': 'user', 'content': comparative_prompt}
    ])
    
    return response['message']['content']

# Run comparative analysis
start_date = mstr_data['date'].min()
end_date = datetime.now()
comparison_data = compare_treasury_alternatives(performance, start_date, end_date)
comparative_analysis = generate_comparative_analysis(comparison_data)
print("Comparative Analysis:")
print(comparative_analysis)

def generate_comprehensive_report(performance_data, risk_data, scenario_data, comparison_data, model='llama3.1:8b'):
    """
    Generate a comprehensive treasury analysis report using Ollama
    """
    
    report_prompt = f"""
    Generate a comprehensive Bitcoin treasury analysis report with the following structure:
    
    EXECUTIVE SUMMARY
    - Portfolio performance: {performance_data['roi_percentage']:.1f}% total return
    - Current value: ${performance_data['current_portfolio_value']:,.0f}
    - Risk assessment: {risk_data['annualized_volatility']*100:.1f}% annual volatility
    
    PERFORMANCE ANALYSIS
    - Total Bitcoin: {performance_data['total_btc_holdings']:,.0f} BTC
    - Average cost basis: ${performance_data['average_cost_basis']:,.0f}
    - Current price: ${performance_data['current_btc_price']:,.0f}
    - Unrealized P&L: ${performance_data['unrealized_pnl']:,.0f}
    - Annualized return: {performance_data['annualized_return']:.1f}%
    
    RISK ASSESSMENT
    - Daily volatility: {risk_data['daily_volatility']*100:.2f}%
    - Value at Risk (95%): ${risk_data['portfolio_var_95']:,.0f}
    
    STRATEGIC RECOMMENDATIONS
    Based on the analysis, provide actionable recommendations for:
    1. Portfolio optimization
    2. Risk management
    3. Future allocation strategies
    4. Market timing considerations
    
    Format as a professional treasury report suitable for board presentation.
    """
    
    response = client.chat(model=model, messages=[
        {'role': 'user', 'content': report_prompt}
    ])
    
    return response['message']['content']

# Generate comprehensive report
comprehensive_report = generate_comprehensive_report(performance, vol_data, scenario_results, comparison_data)
print("Comprehensive Treasury Report:")
print(comprehensive_report)

def setup_monitoring_system(thresholds):
    """
    Set up automated monitoring for treasury performance
    """
    monitoring_config = {
        'price_alerts': {
            'significant_drop': thresholds.get('price_drop', -0.20),  # 20% drop
            'significant_gain': thresholds.get('price_gain', 0.30),   # 30% gain
        },
        'portfolio_alerts': {
            'var_breach': thresholds.get('var_multiple', 2.0),        # 2x normal VaR
            'liquidity_concern': thresholds.get('liquidity_days', 30) # 30 days low volume
        },
        'performance_alerts': {
            'underperformance': thresholds.get('underperform', -0.15), # 15% underperformance
            'rebalancing_trigger': thresholds.get('rebalance', 0.05)   # 5% allocation drift
        }
    }
    
    return monitoring_config

def create_alert_system(monitoring_config, model='llama3.1:8b'):
    """
    Create intelligent alert system using Ollama
    """
    
    alert_prompt = f"""
    Create a monitoring alert system for Bitcoin treasury management with these parameters:
    
    {json.dumps(monitoring_config, indent=2)}
    
    Design alerts for:
    1. Price movement notifications
    2. Risk threshold breaches
    3. Performance warnings
    4. Rebalancing recommendations
    5. Market opportunity alerts
    
    Provide Python pseudocode for implementing this system.
    """
    
    response = client.chat(model=model, messages=[
        {'role': 'user', 'content': alert_prompt}
    ])
    
    return response['message']['content']

# Set up monitoring
monitoring_thresholds = {
    'price_drop': -0.25,
    'price_gain': 0.40,
    'var_multiple': 1.5,
    'liquidity_days': 21,
    'underperform': -0.10,
    'rebalance': 0.08
}

monitoring_config = setup_monitoring_system(monitoring_thresholds)
alert_system = create_alert_system(monitoring_config)
print("Monitoring System Setup:")
print(alert_system)

def create_performance_visualizations(mstr_data, btc_prices, performance_data):
    """
    Create comprehensive visualizations for treasury performance
    """
    
    # Set up the plotting environment
    plt.style.use('seaborn-v0_8')
    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
    
    # Plot 1: Bitcoin Price vs Purchase Timeline
    axes[0, 0].plot(btc_prices.index, btc_prices['Close'], label='Bitcoin Price', alpha=0.7)
    axes[0, 0].scatter(mstr_data['date'], mstr_data['avg_price'], 
                      color='red', s=mstr_data['btc_amount']/100, 
                      label='MicroStrategy Purchases', alpha=0.8)
    axes[0, 0].set_title('Bitcoin Price vs MicroStrategy Purchase Timeline')
    axes[0, 0].set_ylabel('Price (USD)')
    axes[0, 0].legend()
    axes[0, 0].grid(True, alpha=0.3)
    
    # Plot 2: Cumulative Investment vs Portfolio Value
    portfolio_values = []
    for date in mstr_data['date']:
        try:
            price_on_date = btc_prices.loc[btc_prices.index >= date]['Close'].iloc[0]
            cumulative_btc = mstr_data[mstr_data['date'] <= date]['cumulative_btc'].iloc[-1]
            portfolio_value = cumulative_btc * price_on_date
            portfolio_values.append(portfolio_value)
        except:
            portfolio_values.append(0)
    
    axes[0, 1].plot(mstr_data['date'], mstr_data['cumulative_usd'], 
                    label='Cumulative Investment', linewidth=2)
    axes[0, 1].plot(mstr_data['date'], portfolio_values, 
                    label='Portfolio Value', linewidth=2)
    axes[0, 1].set_title('Investment vs Portfolio Value Over Time')
    axes[0, 1].set_ylabel('Value (USD)')
    axes[0, 1].legend()
    axes[0, 1].grid(True, alpha=0.3)
    
    # Plot 3: Cost Basis vs Current Price
    axes[1, 0].axhline(y=performance_data['average_cost_basis'], 
                       color='red', linestyle='--', label='Average Cost Basis')
    axes[1, 0].plot(btc_prices.index, btc_prices['Close'], 
                    label='Bitcoin Price', alpha=0.8)
    axes[1, 0].set_title('Cost Basis vs Market Price')
    axes[1, 0].set_ylabel('Price (USD)')
    axes[1, 0].legend()
    axes[1, 0].grid(True, alpha=0.3)
    
    # Plot 4: Returns Distribution
    daily_returns = btc_prices['Close'].pct_change().dropna()
    axes[1, 1].hist(daily_returns, bins=50, alpha=0.7, color='skyblue')
    axes[1, 1].axvline(x=daily_returns.mean(), color='red', linestyle='--', 
                       label=f'Mean: {daily_returns.mean():.4f}')
    axes[1, 1].set_title('Bitcoin Daily Returns Distribution')
    axes[1, 1].set_xlabel('Daily Return')
    axes[1, 1].set_ylabel('Frequency')
    axes[1, 1].legend()
    axes[1, 1].grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig('bitcoin_treasury_analysis.png', dpi=300, bbox_inches='tight')
    plt.show()

# Create visualizations
create_performance_visualizations(mstr_data, btc_prices, performance)