International Portfolio with Ollama: Currency Risk and Global Diversification

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

# Download financial analysis model
ollama pull llama2:13b

# Verify installation
ollama list

import requests
import json
import pandas as pd
import numpy as np

class OllamaPortfolioAnalyzer:
    def __init__(self, model="llama2:13b"):
        self.model = model
        self.base_url = "http://localhost:11434"
    
    def analyze_currency_exposure(self, portfolio_data):
        """Analyze currency exposure across portfolio holdings"""
        prompt = f"""
        Analyze this international portfolio for currency risk:
        
        Portfolio Holdings:
        {json.dumps(portfolio_data, indent=2)}
        
        Provide:
        1. Currency exposure breakdown
        2. Risk concentration analysis
        3. Hedging recommendations
        4. Correlation concerns
        
        Format as structured JSON with specific percentages and actionable insights.
        """
        
        response = requests.post(
            f"{self.base_url}/api/generate",
            json={
                "model": self.model,
                "prompt": prompt,
                "stream": False
            }
        )
        
        return response.json()["response"]

# Initialize analyzer
analyzer = OllamaPortfolioAnalyzer()

def analyze_geographic_diversification(self, regions_data):
    """Analyze optimal geographic allocation"""
    prompt = f"""
    Analyze geographic diversification for this allocation:
    
    Current Allocation:
    {json.dumps(regions_data, indent=2)}
    
    Consider:
    - Economic cycle correlations
    - Currency stability
    - Political risk factors
    - Market liquidity
    - Growth prospects
    
    Recommend optimal allocation percentages with reasoning.
    Highlight any concentration risks or improvement opportunities.
    """
    
    response = requests.post(
        f"{self.base_url}/api/generate",
        json={
            "model": self.model,
            "prompt": prompt,
            "format": "json"
        }
    )
    
    return json.loads(response.json()["response"])

# Example usage
regions = {
    "North_America": {"allocation": 40, "currencies": ["USD", "CAD"]},
    "Europe": {"allocation": 25, "currencies": ["EUR", "GBP", "CHF"]},
    "Asia_Pacific": {"allocation": 20, "currencies": ["JPY", "AUD", "SGD"]},
    "Emerging_Markets": {"allocation": 15, "currencies": ["CNY", "INR", "BRL"]}
}

diversification_analysis = analyzer.analyze_geographic_diversification(regions)
print(json.dumps(diversification_analysis, indent=2))

def analyze_currency_correlations(self, currency_pairs, timeframe="1Y"):
    """Analyze currency correlation patterns"""
    prompt = f"""
    Analyze correlation patterns for these currency pairs over {timeframe}:
    
    Currency Pairs: {currency_pairs}
    
    Identify:
    1. High correlation pairs (>0.7)
    2. Negative correlation opportunities
    3. Seasonal correlation patterns
    4. Crisis correlation changes
    5. Diversification effectiveness
    
    Recommend portfolio adjustments to minimize correlation risk.
    Include specific correlation coefficients and time periods.
    """
    
    response = requests.post(
        f"{self.base_url}/api/generate",
        json={
            "model": self.model,
            "prompt": prompt,
            "stream": False
        }
    )
    
    return response.json()["response"]

# Analyze major currency correlations
major_currencies = ["USD", "EUR", "JPY", "GBP", "CHF", "AUD", "CAD"]
correlation_analysis = analyzer.analyze_currency_correlations(major_currencies)

def generate_hedging_strategy(self, portfolio, market_conditions):
    """Generate dynamic hedging recommendations"""
    prompt = f"""
    Create a dynamic currency hedging strategy:
    
    Portfolio Details:
    {json.dumps(portfolio, indent=2)}
    
    Market Conditions:
    {json.dumps(market_conditions, indent=2)}
    
    Generate:
    1. Hedge ratio recommendations by currency
    2. Hedging instrument selection (forwards, options, ETFs)
    3. Rebalancing triggers and frequency
    4. Cost-benefit analysis
    5. Risk budget allocation
    
    Prioritize practical implementation with specific thresholds.
    """
    
    response = requests.post(
        f"{self.base_url}/api/generate",
        json={
            "model": self.model,
            "prompt": prompt,
            "format": "json"
        }
    )
    
    return json.loads(response.json()["response"])

# Example portfolio and market conditions
sample_portfolio = {
    "total_value": 1000000,
    "exposures": {
        "EUR": 250000,
        "JPY": 200000,
        "GBP": 150000,
        "CHF": 100000,
        "USD": 300000
    },
    "risk_tolerance": "moderate"
}

market_conditions = {
    "volatility_regime": "high",
    "interest_rate_environment": "rising",
    "geopolitical_risk": "elevated",
    "central_bank_policies": "divergent"
}

hedging_strategy = analyzer.generate_hedging_strategy(sample_portfolio, market_conditions)

def create_risk_monitoring_alerts(self, thresholds):
    """Create currency risk monitoring system"""
    prompt = f"""
    Design a currency risk monitoring system with these thresholds:
    
    Risk Thresholds:
    {json.dumps(thresholds, indent=2)}
    
    Create:
    1. Alert triggers and severity levels
    2. Monitoring metrics and calculations
    3. Response procedures for each alert type
    4. Escalation protocols
    5. Reporting frequency and format
    
    Focus on actionable alerts that prevent overreaction to normal market noise.
    """
    
    response = requests.post(
        f"{self.base_url}/api/generate",
        json={
            "model": self.model,
            "prompt": prompt,
            "stream": False
        }
    )
    
    return response.json()["response"]

# Define risk thresholds
risk_thresholds = {
    "single_currency_exposure": 30,  # Maximum 30% in any currency
    "daily_var_limit": 2,           # 2% daily Value at Risk
    "correlation_ceiling": 0.8,     # Maximum correlation between major exposures
    "hedge_ratio_range": [0.5, 0.9] # Hedge between 50-90% of exposure
}

monitoring_system = analyzer.create_risk_monitoring_alerts(risk_thresholds)

# Calculate actual currency exposure
def calculate_currency_exposure(holdings):
    """Calculate true currency exposure including indirect exposure"""
    total_value = sum(holding['market_value'] for holding in holdings)
    
    currency_exposure = {}
    for holding in holdings:
        # Direct currency exposure
        currency = holding['currency']
        value = holding['market_value']
        
        if currency in currency_exposure:
            currency_exposure[currency] += value
        else:
            currency_exposure[currency] = value
        
        # Add indirect exposure (e.g., multinational companies)
        if 'revenue_exposure' in holding:
            for rev_currency, percentage in holding['revenue_exposure'].items():
                indirect_value = value * percentage / 100
                if rev_currency in currency_exposure:
                    currency_exposure[rev_currency] += indirect_value
                else:
                    currency_exposure[rev_currency] = indirect_value
    
    # Convert to percentages
    exposure_percentages = {
        currency: (value / total_value) * 100 
        for currency, value in currency_exposure.items()
    }
    
    return exposure_percentages

# Example holdings with indirect exposure
holdings = [
    {
        "symbol": "ASML",
        "currency": "EUR", 
        "market_value": 50000,
        "revenue_exposure": {"USD": 60, "EUR": 25, "OTHER": 15}
    },
    {
        "symbol": "TSM",
        "currency": "TWD",
        "market_value": 40000,
        "revenue_exposure": {"USD": 70, "EUR": 15, "TWD": 15}
    }
]

exposure = calculate_currency_exposure(holdings)
print("Currency Exposure:", exposure)

def assess_hedging_needs(currency_exposure, risk_tolerance):
    """Assess which currencies need hedging"""
    prompt = f"""
    Assess hedging needs for this currency exposure:
    
    Currency Exposure: {json.dumps(currency_exposure, indent=2)}
    Risk Tolerance: {risk_tolerance}
    
    For each currency exposure above 10%, recommend:
    1. Hedge or no hedge decision
    2. Hedge ratio if hedging
    3. Hedging instrument preference
    4. Monitoring frequency
    5. Cost estimate
    
    Consider exposure size, volatility, and correlation with base currency.
    """
    
    response = requests.post(
        f"{self.base_url}/api/generate",
        json={
            "model": "llama2:13b",
            "prompt": prompt,
            "stream": False
        }
    )
    
    return response.json()["response"]

# Assess hedging needs
hedging_assessment = assess_hedging_needs(exposure, "moderate")
print(hedging_assessment)

# Portfolio monitoring dashboard data structure
monitoring_data = {
    "last_updated": "2025-07-09",
    "portfolio_value_usd": 1000000,
    "currency_exposures": {
        "EUR": 25.5,
        "JPY": 18.2,
        "GBP": 12.8,
        "CHF": 8.1,
        "USD": 35.4
    },
    "hedge_ratios": {
        "EUR": 0.75,
        "JPY": 0.60,
        "GBP": 0.80,
        "CHF": 0.50
    },
    "risk_metrics": {
        "portfolio_var_1d": 1.8,
        "currency_contribution_var": 0.6,
        "max_single_currency": 35.4,
        "correlation_eur_usd": 0.65
    }
}

def generate_monitoring_report(data):
    """Generate portfolio monitoring report"""
    prompt = f"""
    Generate a currency risk monitoring report:
    
    Portfolio Data:
    {json.dumps(data, indent=2)}
    
    Include:
    1. Risk status summary (Green/Yellow/Red)
    2. Key metric changes from targets
    3. Immediate action items
    4. Hedging effectiveness analysis
    5. Next review recommendations
    
    Focus on actionable insights and clear risk indicators.
    """
    
    response = requests.post(
        f"{self.base_url}/api/generate",
        json={
            "model": "llama2:13b",
            "prompt": prompt,
            "stream": False
        }
    )
    
    return response.json()["response"]

# Generate monitoring report
risk_report = generate_monitoring_report(monitoring_data)
print(risk_report)

def optimize_international_portfolio(constraints, objectives):
    """Optimize portfolio considering multiple objectives"""
    prompt = f"""
    Optimize international portfolio allocation:
    
    Constraints:
    {json.dumps(constraints, indent=2)}
    
    Objectives:
    {json.dumps(objectives, indent=2)}
    
    Provide:
    1. Optimal allocation percentages by region/currency
    2. Expected risk/return profile
    3. Sensitivity analysis for key assumptions
    4. Implementation timeline
    5. Rebalancing triggers
    
    Balance competing objectives with practical implementation considerations.
    """
    
    response = requests.post(
        f"{self.base_url}/api/generate",
        json={
            "model": "llama2:13b",
            "prompt": prompt,
            "format": "json"
        }
    )
    
    return json.loads(response.json()["response"])

# Define optimization parameters
constraints = {
    "max_single_country": 25,
    "max_single_currency": 30,
    "min_developed_markets": 60,
    "max_emerging_markets": 25,
    "liquidity_requirement": "high"
}

objectives = {
    "target_return": 8.5,
    "risk_tolerance": "moderate",
    "currency_risk_limit": 15,
    "esg_preference": "moderate",
    "tax_efficiency": "high"
}

optimization_results = optimize_international_portfolio(constraints, objectives)