Financial Risk Modeling with Ollama: Build Your Local Investment Analysis Platform

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

# Windows users: Download from ollama.ai
# Verify installation
ollama --version

# Download models for financial analysis
ollama pull codellama:13b    # For mathematical computations
ollama pull mistral:7b       # For risk scenario analysis
ollama pull llama2:13b       # For general financial insights

# Verify model availability
ollama list

# portfolio_analyzer.py
import pandas as pd
import numpy as np
import requests
import json
from datetime import datetime, timedelta

class PortfolioAnalyzer:
    def __init__(self, ollama_host="http://localhost:11434"):
        self.ollama_host = ollama_host
        self.portfolio_data = {}
        
    def load_portfolio(self, holdings_file):
        """Load portfolio holdings from CSV or JSON"""
        if holdings_file.endswith('.csv'):
            return pd.read_csv(holdings_file)
        else:
            with open(holdings_file, 'r') as f:
                return json.load(f)
    
    def fetch_market_data(self, symbols, period_days=365):
        """Fetch historical market data for risk calculations"""
        # Implementation for your preferred data source
        # Yahoo Finance, Alpha Vantage, or Bloomberg API
        market_data = {}
        
        for symbol in symbols:
            # Placeholder for actual API calls
            market_data[symbol] = {
                'prices': np.random.randn(period_days).cumsum() + 100,
                'volumes': np.random.randint(1000, 10000, period_days),
                'returns': np.random.randn(period_days) * 0.02
            }
        
        return market_data

def calculate_risk_metrics(self, portfolio_data, market_data):
    """Calculate comprehensive risk metrics for portfolio analysis"""
    
    risk_metrics = {}
    
    # Value at Risk (VaR) calculation
    def calculate_var(returns, confidence_level=0.05):
        return np.percentile(returns, confidence_level * 100)
    
    # Portfolio volatility
    def calculate_portfolio_volatility(weights, cov_matrix):
        return np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
    
    # Sharpe ratio calculation  
    def calculate_sharpe_ratio(returns, risk_free_rate=0.02):
        excess_returns = returns - risk_free_rate/252
        return np.mean(excess_returns) / np.std(excess_returns) * np.sqrt(252)
    
    # Beta calculation against market benchmark
    def calculate_beta(asset_returns, market_returns):
        covariance = np.cov(asset_returns, market_returns)[0][1]
        market_variance = np.var(market_returns)
        return covariance / market_variance
    
    for symbol, data in market_data.items():
        returns = data['returns']
        
        risk_metrics[symbol] = {
            'var_5': calculate_var(returns, 0.05),
            'var_1': calculate_var(returns, 0.01),
            'volatility': np.std(returns) * np.sqrt(252),
            'sharpe_ratio': calculate_sharpe_ratio(returns),
            'max_drawdown': self._calculate_max_drawdown(data['prices']),
            'beta': calculate_beta(returns, market_data.get('SPY', {}).get('returns', returns))
        }
    
    return risk_metrics

def _calculate_max_drawdown(self, prices):
    """Calculate maximum drawdown from price series"""
    peak = np.maximum.accumulate(prices)
    drawdown = (prices - peak) / peak
    return np.min(drawdown)

def analyze_portfolio_risk(self, risk_metrics, portfolio_weights):
    """Generate AI-powered risk analysis using Ollama"""
    
    # Prepare structured data for analysis
    analysis_prompt = self._build_risk_analysis_prompt(risk_metrics, portfolio_weights)
    
    # Send request to local Ollama instance
    response = requests.post(
        f"{self.ollama_host}/api/generate",
        json={
            "model": "mistral:7b",
            "prompt": analysis_prompt,
            "stream": False,
            "options": {
                "temperature": 0.3,  # Lower temperature for factual analysis
                "top_p": 0.9,
                "num_predict": 1000
            }
        }
    )
    
    if response.status_code == 200:
        return response.json()['response']
    else:
        raise Exception(f"Ollama API error: {response.status_code}")

def _build_risk_analysis_prompt(self, risk_metrics, portfolio_weights):
    """Create structured prompt for financial analysis"""
    
    prompt = f"""
    You are a quantitative analyst performing portfolio risk assessment.
    
    PORTFOLIO DATA:
    {json.dumps(risk_metrics, indent=2)}
    
    POSITION WEIGHTS:
    {json.dumps(portfolio_weights, indent=2)}
    
    ANALYSIS REQUIREMENTS:
    1. Identify the 3 highest-risk positions based on VaR and volatility
    2. Calculate portfolio-level risk concentration
    3. Recommend specific hedging strategies
    4. Assess correlation risks between major positions
    5. Suggest optimal rebalancing targets
    
    Provide numerical analysis with specific actionable recommendations.
    Format as structured sections: RISK_ASSESSMENT, RECOMMENDATIONS, QUANTITATIVE_METRICS.
    """
    
    return prompt

def run_scenario_analysis(self, base_portfolio, scenarios):
    """Execute stress testing scenarios using Ollama analysis"""
    
    scenario_results = {}
    
    for scenario_name, scenario_params in scenarios.items():
        # Apply scenario parameters to portfolio
        stressed_returns = self._apply_stress_scenario(
            self.market_data, 
            scenario_params
        )
        
        # Calculate stressed risk metrics
        stressed_metrics = self.calculate_risk_metrics(
            self.portfolio_data, 
            stressed_returns
        )
        
        # Generate AI analysis of scenario impact
        scenario_prompt = f"""
        STRESS TEST SCENARIO: {scenario_name}
        
        SCENARIO PARAMETERS:
        - Market shock: {scenario_params.get('market_shock', 'N/A')}
        - Sector rotation: {scenario_params.get('sector_impact', 'N/A')}
        - Volatility spike: {scenario_params.get('vol_multiplier', 1.0)}x
        
        PORTFOLIO IMPACT:
        Before: {json.dumps(self.base_risk_metrics, indent=2)}
        After: {json.dumps(stressed_metrics, indent=2)}
        
        Analyze the portfolio's resilience and recommend protective measures.
        Focus on: downside protection, liquidity needs, correlation breakdowns.
        """
        
        scenario_analysis = self.query_ollama(scenario_prompt, "codellama:13b")
        
        scenario_results[scenario_name] = {
            'stressed_metrics': stressed_metrics,
            'ai_analysis': scenario_analysis,
            'scenario_params': scenario_params
        }
    
    return scenario_results

def _apply_stress_scenario(self, market_data, scenario_params):
    """Apply stress test parameters to historical market data"""
    
    stressed_data = {}
    
    for symbol, data in market_data.items():
        returns = np.array(data['returns'])
        
        # Apply market shock
        if 'market_shock' in scenario_params:
            shock_magnitude = scenario_params['market_shock']
            returns[0] += shock_magnitude  # Apply shock to first period
        
        # Apply volatility multiplier
        vol_multiplier = scenario_params.get('vol_multiplier', 1.0)
        if vol_multiplier != 1.0:
            returns = returns * vol_multiplier
        
        # Apply sector-specific impacts
        sector_impact = scenario_params.get('sector_impact', {})
        symbol_sector = self._get_symbol_sector(symbol)
        
        if symbol_sector in sector_impact:
            sector_multiplier = sector_impact[symbol_sector]
            returns = returns * sector_multiplier
        
        stressed_data[symbol] = {
            'returns': returns,
            'prices': data['prices'],  # Recalculate if needed
            'volumes': data['volumes']
        }
    
    return stressed_data

# dashboard.py
import streamlit as st
import plotly.graph_objects as go
import plotly.express as px
from datetime import datetime

class RiskMonitoringDashboard:
    def __init__(self, portfolio_analyzer):
        self.analyzer = portfolio_analyzer
        
    def run_dashboard(self):
        """Launch Streamlit dashboard for portfolio monitoring"""
        
        st.title("Ollama Investment Risk Analysis Platform")
        st.sidebar.header("Portfolio Controls")
        
        # Portfolio selection
        portfolio_file = st.sidebar.file_uploader(
            "Upload Portfolio Holdings", 
            type=['csv', 'json']
        )
        
        if portfolio_file:
            # Load and analyze portfolio
            self.analyzer.load_portfolio(portfolio_file)
            
            # Main dashboard tabs
            tab1, tab2, tab3, tab4 = st.tabs([
                "Risk Overview", 
                "Scenario Analysis", 
                "AI Insights",
                "Performance Metrics"
            ])
            
            with tab1:
                self._render_risk_overview()
            
            with tab2:
                self._render_scenario_analysis()
            
            with tab3:
                self._render_ai_insights()
            
            with tab4:
                self._render_performance_metrics()

    def _render_risk_overview(self):
        """Display key risk metrics and visualizations"""
        
        col1, col2, col3 = st.columns(3)
        
        with col1:
            st.metric("Portfolio VaR (5%)", "-2.3%", "-0.4%")
            
        with col2:
            st.metric("Sharpe Ratio", "1.24", "+0.15")
            
        with col3:
            st.metric("Max Drawdown", "-8.7%", "+1.2%")
        
        # Risk concentration chart
        risk_data = self.analyzer.calculate_risk_metrics()
        
        fig = px.bar(
            x=list(risk_data.keys()),
            y=[metrics['var_5'] for metrics in risk_data.values()],
            title="Value at Risk by Position"
        )
        
        st.plotly_chart(fig, use_container_width=True)

    def _render_ai_insights(self):
        """Display Ollama-generated investment insights"""
        
        st.subheader("AI-Powered Risk Analysis")
        
        if st.button("Generate Fresh Analysis"):
            with st.spinner("Analyzing portfolio with Ollama..."):
                insights = self.analyzer.analyze_portfolio_risk()
                
                # Parse and display structured insights
                sections = self._parse_analysis_sections(insights)
                
                for section_name, content in sections.items():
                    st.subheader(section_name.replace('_', ' ').title())
                    st.write(content)
        
        # Display recent analysis results
        if hasattr(self.analyzer, 'last_analysis'):
            st.write(self.analyzer.last_analysis)

def setup_risk_monitoring(self, alert_thresholds):
    """Configure automated risk monitoring with Ollama analysis"""
    
    monitoring_config = {
        'var_threshold': alert_thresholds.get('var_limit', -0.05),
        'concentration_limit': alert_thresholds.get('concentration', 0.25),
        'correlation_warning': alert_thresholds.get('correlation', 0.8),
        'volatility_spike': alert_thresholds.get('vol_multiplier', 2.0)
    }
    
    def check_risk_breaches():
        """Continuous monitoring function"""
        current_metrics = self.calculate_risk_metrics()
        
        alerts = []
        
        for symbol, metrics in current_metrics.items():
            # VaR breach detection
            if metrics['var_5'] < monitoring_config['var_threshold']:
                alert_prompt = f"""
                RISK ALERT: {symbol} VaR breach detected
                
                Current VaR (5%): {metrics['var_5']:.3f}
                Threshold: {monitoring_config['var_threshold']:.3f}
                
                Portfolio context: {json.dumps(current_metrics, indent=2)}
                
                Provide immediate risk assessment and specific hedging recommendations.
                Consider: options strategies, position sizing, correlation hedges.
                """
                
                alert_analysis = self.query_ollama(alert_prompt, "mistral:7b")
                
                alerts.append({
                    'type': 'VAR_BREACH',
                    'symbol': symbol,
                    'severity': 'HIGH',
                    'analysis': alert_analysis,
                    'timestamp': datetime.now()
                })
        
        return alerts
    
    return check_risk_breaches

def analyze_market_regimes(self, lookback_period=252):
    """Identify market regimes for dynamic portfolio allocation"""
    
    regime_prompt = f"""
    MARKET REGIME ANALYSIS REQUEST
    
    Historical Data Summary:
    - Analysis period: {lookback_period} trading days
    - Asset classes: {list(self.market_data.keys())}
    - Volatility levels: {self._calculate_volatility_summary()}
    - Correlation patterns: {self._calculate_correlation_summary()}
    
    REGIME DETECTION TASK:
    1. Identify current market regime (bull/bear/sideways)
    2. Detect regime change probability in next 30 days
    3. Recommend portfolio allocation adjustments
    4. Suggest tactical overlays (momentum/mean reversion)
    5. Assess macro risk factors influence
    
    Provide specific allocation percentages and reasoning.
    Consider: risk parity, momentum signals, volatility targeting.
    """
    
    regime_analysis = self.query_ollama(regime_prompt, "llama2:13b")
    
    # Parse allocation recommendations
    allocations = self._extract_allocation_targets(regime_analysis)
    
    return {
        'regime_analysis': regime_analysis,
        'recommended_allocations': allocations,
        'confidence_score': self._calculate_confidence_score(regime_analysis)
    }

def optimize_portfolio_weights(self, target_allocations, constraints):
    """Optimize portfolio weights using AI-guided constraints"""
    
    optimization_prompt = f"""
    PORTFOLIO OPTIMIZATION REQUEST
    
    Current Holdings: {json.dumps(self.portfolio_data, indent=2)}
    Target Allocations: {json.dumps(target_allocations, indent=2)}
    
    Constraints:
    - Maximum position size: {constraints.get('max_weight', 0.20)}
    - Minimum liquidity requirement: {constraints.get('min_liquidity', 1000000)}
    - Sector concentration limit: {constraints.get('sector_limit', 0.30)}
    - Transaction cost budget: {constraints.get('transaction_cost', 0.002)}
    
    OPTIMIZATION OBJECTIVES:
    1. Minimize tracking error to target allocation
    2. Respect all portfolio constraints
    3. Minimize transaction costs
    4. Maintain desired risk characteristics
    5. Consider tax implications
    
    Provide specific trade recommendations with rationale.
    Format: SYMBOL | ACTION | QUANTITY | REASONING
    """
    
    optimization_result = self.query_ollama(optimization_prompt, "codellama:13b")
    
    return self._parse_trade_recommendations(optimization_result)

# Dockerfile
FROM ollama/ollama:latest

# Install Python dependencies
RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    git \
    && rm -rf /var/lib/apt/lists/*

# Copy application code
COPY . /app
WORKDIR /app

# Install Python requirements
RUN pip3 install -r requirements.txt

# Download required models
RUN ollama pull mistral:7b && \
    ollama pull codellama:13b && \
    ollama pull llama2:13b

# Expose ports
EXPOSE 11434 8501

# Start services
CMD ["sh", "-c", "ollama serve & streamlit run dashboard.py --server.port=8501 --server.address=0.0.0.0"]

# config.py
OLLAMA_CONFIG = {
    'models': {
        'risk_analysis': {
            'name': 'mistral:7b',
            'options': {
                'num_ctx': 4096,        # Context window
                'temperature': 0.2,      # Low for factual analysis
                'top_p': 0.9,
                'repeat_penalty': 1.1,
                'num_gpu': 1            # GPU acceleration
            }
        },
        'portfolio_optimization': {
            'name': 'codellama:13b',
            'options': {
                'num_ctx': 8192,        # Larger context for complex calculations
                'temperature': 0.1,      # Very low for mathematical accuracy
                'top_p': 0.95,
                'num_gpu': 1
            }
        }
    },
    'performance': {
        'concurrent_requests': 4,        # Parallel analysis requests
        'cache_results': True,           # Cache repeated analyses
        'batch_processing': True,        # Batch similar requests
        'gpu_memory_fraction': 0.8       # GPU memory allocation
    }
}

def configure_ollama_performance():
    """Apply performance optimizations for financial analysis workloads"""
    
    # Configure GPU settings if available
    import subprocess
    
    try:
        # Check for NVIDIA GPU
        result = subprocess.run(['nvidia-smi'], capture_output=True)
        if result.returncode == 0:
            print("GPU acceleration available")
            return OLLAMA_CONFIG
    except FileNotFoundError:
        print("No GPU detected, using CPU mode")
        
        # Adjust config for CPU-only deployment
        for model_config in OLLAMA_CONFIG['models'].values():
            model_config['options']['num_gpu'] = 0
            model_config['options']['num_thread'] = 8  # CPU thread count
    
    return OLLAMA_CONFIG

# security.py
import hashlib
import hmac
from cryptography.fernet import Fernet
import logging

class FinancialDataSecurity:
    def __init__(self, encryption_key=None):
        self.encryption_key = encryption_key or self._generate_key()
        self.fernet = Fernet(self.encryption_key)
        
        # Setup audit logging
        logging.basicConfig(
            filename='portfolio_audit.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        
    def encrypt_portfolio_data(self, portfolio_data):
        """Encrypt sensitive portfolio information"""
        serialized_data = json.dumps(portfolio_data).encode()
        encrypted_data = self.fernet.encrypt(serialized_data)
        
        # Log access without exposing data
        logging.info(f"Portfolio data encrypted - size: {len(serialized_data)} bytes")
        
        return encrypted_data
    
    def decrypt_portfolio_data(self, encrypted_data):
        """Decrypt portfolio data for analysis"""
        try:
            decrypted_data = self.fernet.decrypt(encrypted_data)
            portfolio_data = json.loads(decrypted_data.decode())
            
            logging.info("Portfolio data successfully decrypted for analysis")
            return portfolio_data
            
        except Exception as e:
            logging.error(f"Decryption failed: {str(e)}")
            raise
    
    def hash_sensitive_identifiers(self, account_ids):
        """Hash account identifiers for privacy"""
        hashed_ids = {}
        
        for account_id in account_ids:
            # Use HMAC for consistent hashing
            hashed_id = hmac.new(
                self.encryption_key,
                account_id.encode(),
                hashlib.sha256
            ).hexdigest()[:16]  # Truncate for readability
            
            hashed_ids[account_id] = hashed_id
        
        return hashed_ids
    
    def audit_ollama_requests(self, prompt, response, model_used):
        """Log AI requests for compliance auditing"""
        
        # Hash the prompt to avoid logging sensitive data
        prompt_hash = hashlib.sha256(prompt.encode()).hexdigest()[:16]
        
        audit_entry = {
            'timestamp': datetime.now().isoformat(),
            'model': model_used,
            'prompt_hash': prompt_hash,
            'response_length': len(response),
            'request_type': 'financial_analysis'
        }
        
        logging.info(f"Ollama request audit: {json.dumps(audit_entry)}")