Retirement Planning with Ollama: 401k and IRA Optimization Calculator

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

# Pull the recommended model for financial calculations
ollama pull llama2:13b

# Verify installation
ollama list

mkdir retirement-planner
cd retirement-planner
mkdir calculations data outputs
touch main.py config.py calculations.py

# calculations.py
import json
import subprocess
from typing import Dict, List, Tuple

class RetirementCalculator:
    def __init__(self):
        self.current_year = 2025
        self.contribution_limits = {
            '401k': 23500,  # 2025 limit
            '401k_catch_up': 7500,  # Age 50+ additional
            'ira': 7000,    # 2025 limit
            'ira_catch_up': 1000   # Age 50+ additional
        }
    
    def calculate_401k_optimization(self, 
                                  salary: int, 
                                  age: int, 
                                  current_contribution: int,
                                  employer_match: float,
                                  tax_bracket: float) -> Dict:
        """
        Calculate optimal 401k contribution strategy
        Returns recommendations for traditional vs Roth contributions
        """
        
        # Determine maximum contribution based on age
        max_contribution = self.contribution_limits['401k']
        if age >= 50:
            max_contribution += self.contribution_limits['401k_catch_up']
        
        # Calculate employer match optimization
        match_threshold = min(salary * employer_match, max_contribution)
        
        # Prepare prompt for Ollama analysis
        prompt = f"""
        Analyze this 401k situation and provide optimization recommendations:
        
        Current Situation:
        - Annual Salary: ${salary:,}
        - Age: {age}
        - Current Contribution: ${current_contribution:,}
        - Employer Match: {employer_match*100}%
        - Tax Bracket: {tax_bracket*100}%
        - Max Contribution Allowed: ${max_contribution:,}
        - Employer Match Threshold: ${match_threshold:,}
        
        Calculate and recommend:
        1. Optimal contribution amount to maximize employer match
        2. Traditional vs Roth 401k allocation strategy
        3. Tax savings analysis for different contribution levels
        4. Projected account balance at retirement (age 67)
        
        Provide specific dollar amounts and percentages in your analysis.
        """
        
        return self._query_ollama(prompt)
    
    def _query_ollama(self, prompt: str) -> Dict:
        """Send query to Ollama and parse response"""
        try:
            result = subprocess.run([
                'ollama', 'run', 'llama2:13b', prompt
            ], capture_output=True, text=True, timeout=60)
            
            return {
                'status': 'success',
                'analysis': result.stdout,
                'timestamp': self.current_year
            }
        except Exception as e:
            return {
                'status': 'error',
                'message': str(e)
            }

def calculate_ira_strategy(self, 
                          salary: int, 
                          age: int,
                          filing_status: str,
                          existing_401k: int) -> Dict:
    """
    Determine optimal IRA contribution and type (Traditional vs Roth)
    Considers income limits and tax implications
    """
    
    # IRA contribution limits based on income and filing status
    ira_limits = {
        'single': {'roth_phaseout': (138000, 153000), 'trad_phaseout': (73000, 83000)},
        'married': {'roth_phaseout': (218000, 228000), 'trad_phaseout': (116000, 136000)}
    }
    
    max_ira = self.contribution_limits['ira']
    if age >= 50:
        max_ira += self.contribution_limits['ira_catch_up']
    
    prompt = f"""
    Analyze this IRA contribution strategy:
    
    Taxpayer Profile:
    - Annual Income: ${salary:,}
    - Age: {age}
    - Filing Status: {filing_status}
    - Current 401k Contribution: ${existing_401k:,}
    - Maximum IRA Contribution: ${max_ira:,}
    
    Income Limits (2025):
    - Roth IRA Phaseout: ${ira_limits[filing_status]['roth_phaseout']}
    - Traditional IRA Deduction Phaseout: ${ira_limits[filing_status]['trad_phaseout']}
    
    Recommend:
    1. Eligible IRA types based on income
    2. Optimal contribution amount for each type
    3. Tax advantages of Traditional vs Roth IRA
    4. Backdoor Roth IRA strategy if applicable
    5. Total retirement savings strategy combining 401k and IRA
    
    Include specific calculations showing tax savings and long-term growth projections.
    """
    
    return self._query_ollama(prompt)

# main.py
from calculations import RetirementCalculator
import json

def run_comprehensive_analysis(user_profile: Dict) -> Dict:
    """
    Generate complete retirement planning analysis
    """
    calculator = RetirementCalculator()
    
    # Extract user data
    salary = user_profile['salary']
    age = user_profile['age']
    current_401k = user_profile.get('current_401k_contribution', 0)
    employer_match = user_profile.get('employer_match', 0.03)
    tax_bracket = user_profile.get('tax_bracket', 0.22)
    filing_status = user_profile.get('filing_status', 'single')
    
    # Run 401k optimization
    print("Analyzing 401k optimization...")
    k401_analysis = calculator.calculate_401k_optimization(
        salary, age, current_401k, employer_match, tax_bracket
    )
    
    # Run IRA strategy analysis
    print("Calculating IRA strategy...")
    ira_analysis = calculator.calculate_ira_strategy(
        salary, age, filing_status, current_401k
    )
    
    # Generate comprehensive recommendations
    comprehensive_prompt = f"""
    Create a unified retirement planning strategy based on these analyses:
    
    401k Analysis Results:
    {k401_analysis.get('analysis', 'Analysis failed')}
    
    IRA Analysis Results:
    {ira_analysis.get('analysis', 'Analysis failed')}
    
    Provide:
    1. Total recommended annual retirement contributions
    2. Optimal account allocation strategy
    3. Tax optimization across all accounts
    4. Milestone targets for ages 30, 40, 50, 60
    5. Specific action items to implement this strategy
    
    Format as a clear, actionable retirement plan.
    """
    
    final_strategy = calculator._query_ollama(comprehensive_prompt)
    
    return {
        '401k_optimization': k401_analysis,
        'ira_strategy': ira_analysis,
        'comprehensive_plan': final_strategy,
        'user_profile': user_profile
    }

# Example usage
if __name__ == "__main__":
    # Sample user profile
    user_data = {
        'salary': 85000,
        'age': 32,
        'current_401k_contribution': 5100,  # 6% of salary
        'employer_match': 0.04,  # 4% match
        'tax_bracket': 0.22,
        'filing_status': 'single'
    }
    
    results = run_comprehensive_analysis(user_data)
    
    # Save results to file
    with open('outputs/retirement_analysis.json', 'w') as f:
        json.dump(results, f, indent=2)
    
    print("Analysis complete! Check outputs/retirement_analysis.json for results.")

def analyze_tax_optimization(self, portfolio_data: Dict) -> Dict:
    """
    Integrate tax-loss harvesting with retirement planning
    """
    prompt = f"""
    Analyze tax optimization opportunities across retirement and taxable accounts:
    
    Account Balances:
    - 401k Traditional: ${portfolio_data.get('trad_401k', 0):,}
    - 401k Roth: ${portfolio_data.get('roth_401k', 0):,}
    - Traditional IRA: ${portfolio_data.get('trad_ira', 0):,}
    - Roth IRA: ${portfolio_data.get('roth_ira', 0):,}
    - Taxable Investments: ${portfolio_data.get('taxable', 0):,}
    
    Current Tax Situation:
    - Income: ${portfolio_data.get('income', 0):,}
    - Tax Bracket: {portfolio_data.get('tax_bracket', 0)*100}%
    
    Recommend:
    1. Optimal asset allocation across account types
    2. Tax-loss harvesting opportunities
    3. Roth conversion strategies
    4. Withdrawal sequencing in retirement
    5. Estate planning considerations
    
    Provide specific dollar amounts and timing for each recommendation.
    """
    
    return self._query_ollama(prompt)

def plan_retirement_withdrawals(self, 
                              retirement_accounts: Dict,
                              retirement_age: int,
                              life_expectancy: int,
                              desired_income: int) -> Dict:
    """
    Calculate optimal withdrawal strategy during retirement
    """
    
    total_savings = sum(retirement_accounts.values())
    retirement_years = life_expectancy - retirement_age
    
    prompt = f"""
    Design an optimal retirement withdrawal strategy:
    
    Retirement Portfolio:
    - Traditional 401k/IRA: ${retirement_accounts.get('traditional', 0):,}
    - Roth 401k/IRA: ${retirement_accounts.get('roth', 0):,}
    - Taxable Accounts: ${retirement_accounts.get('taxable', 0):,}
    - Total Portfolio: ${total_savings:,}
    
    Retirement Parameters:
    - Retirement Age: {retirement_age}
    - Life Expectancy: {life_expectancy}
    - Years in Retirement: {retirement_years}
    - Desired Annual Income: ${desired_income:,}
    
    Calculate:
    1. Sustainable withdrawal rate
    2. Annual withdrawal amounts by account type
    3. Tax-efficient withdrawal sequencing
    4. Required Minimum Distribution (RMD) planning
    5. Social Security optimization timing
    6. Healthcare cost considerations
    
    Provide year-by-year withdrawal recommendations for the first 10 years of retirement.
    """
    
    return self._query_ollama(prompt)

# config.py
USER_PROFILE = {
    'personal_info': {
        'age': 35,
        'filing_status': 'married',
        'state': 'CA',  # For state tax considerations
        'retirement_age_goal': 65
    },
    'income': {
        'salary': 95000,
        'bonus': 10000,
        'spouse_income': 75000
    },
    'current_retirement': {
        '401k_traditional': 125000,
        '401k_roth': 25000,
        'ira_traditional': 15000,
        'ira_roth': 35000,
        'current_401k_contribution': 8000
    },
    'employer_benefits': {
        'match_percentage': 0.04,
        'match_cap': 4000,
        'vesting_schedule': 'immediate'
    }
}

# Run the main analysis
python main.py

# View results
cat outputs/retirement_analysis.json

# Check if Ollama is running
ollama ps

# Restart Ollama service
ollama serve

# Test with simple query
ollama run llama2:13b "Calculate 10% of 50000"

def verify_calculations(results: Dict) -> bool:
    """
    Verify key calculations are within reasonable ranges
    """
    # Extract numeric values from AI response
    # Cross-check against known limits and formulas
    # Flag any suspicious results for manual review
    pass

# Example: Connect to broker API for current balances
import requests

def fetch_account_balances(api_key: str) -> Dict:
    """
    Fetch current account balances from broker API
    """
    # Implementation depends on your broker's API
    # Common providers: Schwab, Fidelity, Vanguard
    pass

from datetime import datetime, timedelta

def schedule_quarterly_review(user_profile: Dict):
    """
    Generate calendar reminders for retirement plan reviews
    """
    next_review = datetime.now() + timedelta(days=90)
    print(f"Next retirement plan review scheduled: {next_review.strftime('%Y-%m-%d')}")