Stablecoin Interest Rate Tracker: Ollama DeFi vs Traditional Banking Returns

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

# Install Python dependencies
pip install requests pandas matplotlib web3

import requests
import pandas as pd
from datetime import datetime

class DeFiRateTracker:
    def __init__(self):
        self.aave_url = "https://api.aave.com/data/rates/v2"
        self.compound_url = "https://api.compound.finance/api/v2/ctoken"
        
    def get_aave_rates(self):
        """Fetch current Aave lending rates for major stablecoins"""
        response = requests.get(self.aave_url)
        data = response.json()
        
        # Extract USDC, USDT, DAI rates
        stablecoin_rates = {}
        for reserve in data['reserves']:
            if reserve['symbol'] in ['USDC', 'USDT', 'DAI']:
                rate = float(reserve['liquidityRate']) * 100
                stablecoin_rates[reserve['symbol']] = {
                    'apy': round(rate, 2),
                    'protocol': 'Aave',
                    'timestamp': datetime.now()
                }
        
        return stablecoin_rates

    def get_compound_rates(self):
        """Collect Compound protocol yields for stablecoins"""
        response = requests.get(self.compound_url)
        data = response.json()
        
        compound_rates = {}
        stablecoin_ctokens = {
            'cUSDC': 'USDC',
            'cDAI': 'DAI', 
            'cUSDT': 'USDT'
        }
        
        for ctoken in data['cToken']:
            if ctoken['symbol'] in stablecoin_ctokens:
                underlying = stablecoin_ctokens[ctoken['symbol']]
                supply_apy = float(ctoken['supply_rate']['value']) * 100
                
                compound_rates[underlying] = {
                    'apy': round(supply_apy, 2),
                    'protocol': 'Compound',
                    'timestamp': datetime.now()
                }
        
        return compound_rates

class TraditionalBankTracker:
    def __init__(self):
        self.bank_rates = {
            'Chase Savings': 0.01,
            'Wells Fargo Savings': 0.02,
            'Marcus by Goldman Sachs': 4.50,
            'Ally Online Savings': 4.25,
            'Capital One 360': 4.10
        }
    
    def get_bank_rates(self):
        """Return current traditional banking rates"""
        bank_data = {}
        for bank, rate in self.bank_rates.items():
            bank_data[bank] = {
                'apy': rate,
                'type': 'Traditional Banking',
                'fdic_insured': True,
                'timestamp': datetime.now()
            }
        
        return bank_data

    def get_high_yield_rates(self):
        """Fetch rates from top online banks"""
        high_yield_banks = {
            'Marcus Goldman Sachs': 4.50,
            'American Express Personal': 4.35,
            'Discover Online Savings': 4.30,
            'CIT Bank Savings Connect': 4.15
        }
        
        return {bank: {'apy': rate, 'type': 'High-Yield Savings'} 
                for bank, rate in high_yield_banks.items()}

import subprocess
import json

class OllamaAnalyzer:
    def __init__(self):
        self.model = "llama2"
        
    def setup_ollama(self):
        """Download and configure Ollama model"""
        subprocess.run(["ollama", "pull", self.model])
        
    def analyze_rates(self, defi_rates, bank_rates):
        """Use Ollama to analyze rate differences and trends"""
        
        # Prepare data for analysis
        analysis_prompt = f"""
        Compare these DeFi and traditional banking rates:
        
        DeFi Rates:
        {json.dumps(defi_rates, indent=2)}
        
        Traditional Rates:
        {json.dumps(bank_rates, indent=2)}
        
        Provide analysis on:
        1. Highest yield opportunities
        2. Risk vs reward comparison
        3. Trend predictions
        """
        
        # Run Ollama analysis
        result = subprocess.run([
            "ollama", "run", self.model, analysis_prompt
        ], capture_output=True, text=True)
        
        return result.stdout

    def get_recommendations(self, user_risk_profile, investment_amount):
        """Generate personalized stablecoin allocation advice"""
        
        recommendation_prompt = f"""
        User Profile:
        - Risk tolerance: {user_risk_profile}
        - Investment amount: ${investment_amount:,}
        
        Based on current rates, recommend allocation between:
        1. DeFi stablecoin yields
        2. Traditional high-yield savings
        3. Risk management considerations
        
        Provide specific percentages and reasoning.
        """
        
        result = subprocess.run([
            "ollama", "run", self.model, recommendation_prompt
        ], capture_output=True, text=True)
        
        return result.stdout

class StablecoinRateTracker:
    def __init__(self):
        self.defi_tracker = DeFiRateTracker()
        self.bank_tracker = TraditionalBankTracker()
        self.analyzer = OllamaAnalyzer()
        
    def collect_all_rates(self):
        """Gather rates from all sources"""
        print("Collecting DeFi rates...")
        aave_rates = self.defi_tracker.get_aave_rates()
        compound_rates = self.defi_tracker.get_compound_rates()
        
        print("Collecting traditional banking rates...")
        bank_rates = self.bank_tracker.get_bank_rates()
        high_yield_rates = self.bank_tracker.get_high_yield_rates()
        
        return {
            'defi': {**aave_rates, **compound_rates},
            'traditional': {**bank_rates, **high_yield_rates}
        }
    
    def generate_report(self):
        """Create comprehensive rate comparison report"""
        rates = self.collect_all_rates()
        
        # Ollama analysis
        analysis = self.analyzer.analyze_rates(
            rates['defi'], 
            rates['traditional']
        )
        
        return {
            'rates': rates,
            'analysis': analysis,
            'timestamp': datetime.now()
        }

import matplotlib.pyplot as plt
import seaborn as sns

def create_rate_dashboard(rates_data):
    """Generate visual dashboard of all rates"""
    
    # Prepare data for plotting
    all_rates = []
    for category, rates in rates_data.items():
        for platform, data in rates.items():
            all_rates.append({
                'Platform': platform,
                'APY': data['apy'],
                'Category': category.title(),
                'Type': data.get('protocol', data.get('type', 'Unknown'))
            })
    
    df = pd.DataFrame(all_rates)
    
    # Create comparison chart
    plt.figure(figsize=(15, 8))
    
    # Bar chart comparing all rates
    sns.barplot(data=df, x='Platform', y='APY', hue='Category')
    plt.xticks(rotation=45)
    plt.title('Stablecoin Interest Rates: DeFi vs Traditional Banking')
    plt.ylabel('Annual Percentage Yield (%)')
    
    # Add value labels on bars
    for i, bar in enumerate(plt.gca().patches):
        height = bar.get_height()
        plt.text(bar.get_x() + bar.get_width()/2., height + 0.1,
                f'{height:.2f}%', ha='center', va='bottom')
    
    plt.tight_layout()
    plt.savefig('stablecoin_rates_comparison.png', dpi=300, bbox_inches='tight')
    plt.show()
    
    return df

def main():
    """Main execution function"""
    print("🏦 Stablecoin Interest Rate Tracker Starting...")
    
    # Initialize tracker
    tracker = StablecoinRateTracker()
    
    # Generate daily report
    report = tracker.generate_report()
    
    # Create visualizations
    rates_df = create_rate_dashboard(report['rates'])
    
    # Display top opportunities
    print("\n📊 Top Yield Opportunities:")
    print("-" * 50)
    
    all_rates = []
    for category, platforms in report['rates'].items():
        for platform, data in platforms.items():
            all_rates.append((platform, data['apy'], category))
    
    # Sort by APY descending
    top_rates = sorted(all_rates, key=lambda x: x[1], reverse=True)[:5]
    
    for i, (platform, apy, category) in enumerate(top_rates, 1):
        print(f"{i}. {platform}: {apy:.2f}% APY ({category})")
    
    # Show Ollama analysis
    print(f"\n🤖 AI Analysis:\n{report['analysis']}")

if __name__ == "__main__":
    main()

class RateAlertSystem:
    def __init__(self, threshold_change=0.5):
        self.threshold = threshold_change
        self.previous_rates = {}
        
    def check_rate_changes(self, current_rates):
        """Monitor for significant rate movements"""
        alerts = []
        
        for platform, data in current_rates.items():
            current_apy = data['apy']
            
            if platform in self.previous_rates:
                previous_apy = self.previous_rates[platform]
                change = abs(current_apy - previous_apy)
                
                if change >= self.threshold:
                    direction = "increased" if current_apy > previous_apy else "decreased"
                    alerts.append(f"{platform} rate {direction} by {change:.2f}%")
        
        self.previous_rates = {p: d['apy'] for p, d in current_rates.items()}
        return alerts

def optimize_portfolio(total_amount, risk_tolerance):
    """Calculate optimal allocation across platforms"""
    
    optimization_prompt = f"""
    Portfolio optimization for ${total_amount:,}:
    Risk tolerance: {risk_tolerance}/10
    
    Suggest allocation percentages between:
    - High-yield DeFi (8-12% APY, higher risk)
    - Moderate DeFi (5-8% APY, medium risk) 
    - Traditional high-yield (4-5% APY, low risk)
    - FDIC savings (0.5-4% APY, minimal risk)
    
    Provide specific percentages and monthly income projections.
    """
    
    # Process with Ollama
    result = subprocess.run([
        "ollama", "run", "llama2", optimization_prompt
    ], capture_output=True, text=True)
    
    return result.stdout

# Add to crontab for daily 9 AM updates
0 9 * * * /usr/bin/python3 /path/to/stablecoin_tracker.py

from flask import Flask, jsonify, render_template

app = Flask(__name__)
tracker = StablecoinRateTracker()

@app.route('/api/rates')
def get_current_rates():
    """API endpoint for current rates"""
    rates = tracker.collect_all_rates()
    return jsonify(rates)

@app.route('/dashboard')
def dashboard():
    """Web dashboard for rate comparison"""
    report = tracker.generate_report()
    return render_template('dashboard.html', report=report)

if __name__ == '__main__':
    app.run(debug=True, port=5000)