Memecoin vs Utility Token Performance: Ollama Investment Decision Framework

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

# Start Ollama service
ollama serve

# Pull financial analysis models
ollama pull llama3.1:8b
ollama pull deepseek-r1:7b

# requirements.txt
ollama==0.1.7
pandas==2.1.4
requests==2.31.0
python-binance==1.0.19
ccxt==4.1.77
numpy==1.25.2
python-dotenv==1.0.0

import ollama
import pandas as pd
import ccxt
from datetime import datetime, timedelta
import json

class CryptoPerformanceAnalyzer:
    def __init__(self, model_name="deepseek-r1:7b"):
        self.model = model_name
        self.exchange = ccxt.binance()
        
    def get_price_data(self, symbol, timeframe='1d', limit=100):
        """Fetch historical price data"""
        try:
            ohlcv = self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
            df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            return df
        except Exception as e:
            print(f"Error fetching {symbol}: {e}")
            return None
    
    def calculate_metrics(self, df):
        """Calculate performance metrics"""
        if df is None or len(df) < 2:
            return None
            
        # Basic metrics
        total_return = (df['close'].iloc[-1] / df['close'].iloc[0] - 1) * 100
        volatility = df['close'].pct_change().std() * (365 ** 0.5) * 100
        
        # Risk-adjusted metrics
        daily_returns = df['close'].pct_change().dropna()
        sharpe_ratio = (daily_returns.mean() / daily_returns.std()) * (365 ** 0.5) if daily_returns.std() > 0 else 0
        
        # Maximum drawdown
        rolling_max = df['close'].expanding().max()
        drawdown = (df['close'] - rolling_max) / rolling_max
        max_drawdown = drawdown.min() * 100
        
        return {
            'total_return': total_return,
            'volatility': volatility,
            'sharpe_ratio': sharpe_ratio,
            'max_drawdown': max_drawdown,
            'current_price': df['close'].iloc[-1]
        }

def classify_token_type(self, symbol, market_cap=None):
    """Classify token as memecoin or utility using AI analysis"""
    
    # Get basic token info
    try:
        ticker = self.exchange.fetch_ticker(symbol)
        volume_24h = ticker['quoteVolume']
    except:
        volume_24h = 0
    
    # AI classification prompt
    classification_prompt = f"""
    Analyze this cryptocurrency and classify it as either MEMECOIN or UTILITY:
    
    Symbol: {symbol}
    24h Volume: ${volume_24h:,.0f}
    Market Cap: ${market_cap or 'Unknown'}
    
    Classification criteria:
    MEMECOIN: Community-driven, meme-based, viral marketing, minimal utility
    UTILITY: Real-world applications, smart contracts, ecosystem usage, transaction fees
    
    Examples:
    - DOGE, SHIB, PEPE = MEMECOIN
    - ETH, BNB, LINK = UTILITY
    
    Respond with only: MEMECOIN or UTILITY
    """
    
    try:
        response = ollama.chat(
            model=self.model,
            messages=[{'role': 'user', 'content': classification_prompt}]
        )
        
        result = response['message']['content'].strip().upper()
        return 'MEMECOIN' if 'MEMECOIN' in result else 'UTILITY'
    except:
        return 'UNKNOWN'

def compare_categories(self, memecoin_list, utility_list, days=90):
    """Compare memecoin vs utility token performance"""
    
    results = {
        'memecoins': {},
        'utilities': {},
        'summary': {}
    }
    
    # Analyze memecoins
    for symbol in memecoin_list:
        df = self.get_price_data(symbol, limit=days)
        metrics = self.calculate_metrics(df)
        if metrics:
            results['memecoins'][symbol] = metrics
    
    # Analyze utility tokens
    for symbol in utility_list:
        df = self.get_price_data(symbol, limit=days)
        metrics = self.calculate_metrics(df)
        if metrics:
            results['utilities'][symbol] = metrics
    
    # Calculate category averages
    if results['memecoins']:
        meme_returns = [m['total_return'] for m in results['memecoins'].values()]
        meme_volatility = [m['volatility'] for m in results['memecoins'].values()]
        
        results['summary']['memecoin_avg_return'] = sum(meme_returns) / len(meme_returns)
        results['summary']['memecoin_avg_volatility'] = sum(meme_volatility) / len(meme_volatility)
    
    if results['utilities']:
        util_returns = [u['total_return'] for u in results['utilities'].values()]
        util_volatility = [u['volatility'] for u in results['utilities'].values()]
        
        results['summary']['utility_avg_return'] = sum(util_returns) / len(util_returns)
        results['summary']['utility_avg_volatility'] = sum(util_volatility) / len(util_volatility)
    
    return results

def generate_investment_recommendation(self, analysis_results):
    """Generate AI-powered investment recommendation"""
    
    summary = analysis_results['summary']
    
    recommendation_prompt = f"""
    As a professional cryptocurrency analyst, provide investment recommendations based on this data:
    
    PERFORMANCE ANALYSIS (90 days):
    
    Memecoins:
    - Average Return: {summary.get('memecoin_avg_return', 0):.2f}%
    - Average Volatility: {summary.get('memecoin_avg_volatility', 0):.2f}%
    
    Utility Tokens:
    - Average Return: {summary.get('utility_avg_return', 0):.2f}%
    - Average Volatility: {summary.get('utility_avg_volatility', 0):.2f}%
    
    Provide analysis in this format:
    
    1. WINNER: [Category with better risk-adjusted returns]
    2. RISK LEVEL: [Low/Medium/High for each category]
    3. ALLOCATION: [Suggested portfolio % for each]
    4. REASONING: [2-3 sentence explanation]
    5. MARKET OUTLOOK: [Bullish/Bearish/Neutral with timeframe]
    
    Focus on risk-adjusted returns, not just absolute gains.
    """
    
    try:
        response = ollama.chat(
            model=self.model,
            messages=[{'role': 'user', 'content': recommendation_prompt}]
        )
        
        return response['message']['content']
    except Exception as e:
        return f"Analysis error: {e}"

def screen_top_performers(self, min_volume=1000000, max_volatility=200):
    """Screen and rank cryptocurrencies by performance"""
    
    # Get top cryptocurrencies by volume
    markets = self.exchange.load_markets()
    usdt_pairs = [symbol for symbol in markets.keys() if '/USDT' in symbol]
    
    screened_tokens = []
    
    for symbol in usdt_pairs[:50]:  # Top 50 by volume
        try:
            # Get recent performance
            df = self.get_price_data(symbol, limit=30)
            metrics = self.calculate_metrics(df)
            
            if metrics and metrics['volatility'] < max_volatility:
                # Classify token type
                token_type = self.classify_token_type(symbol)
                
                screened_tokens.append({
                    'symbol': symbol,
                    'type': token_type,
                    'return_30d': metrics['total_return'],
                    'volatility': metrics['volatility'],
                    'sharpe_ratio': metrics['sharpe_ratio'],
                    'max_drawdown': metrics['max_drawdown']
                })
                
        except Exception as e:
            continue
    
    # Sort by risk-adjusted returns
    screened_tokens.sort(key=lambda x: x['sharpe_ratio'], reverse=True)
    
    return screened_tokens[:10]  # Top 10 performers

def run_complete_analysis():
    """Execute full memecoin vs utility analysis"""
    
    analyzer = CryptoPerformanceAnalyzer()
    
    # Define test portfolios
    memecoins = ['DOGE/USDT', 'SHIB/USDT', 'PEPE/USDT', 'FLOKI/USDT']
    utilities = ['ETH/USDT', 'BNB/USDT', 'LINK/USDT', 'UNI/USDT']
    
    print("🔍 Analyzing Performance...")
    results = analyzer.compare_categories(memecoins, utilities, days=90)
    
    print("\n📊 Performance Summary:")
    print(f"Memecoin Avg Return: {results['summary'].get('memecoin_avg_return', 0):.2f}%")
    print(f"Utility Avg Return: {results['summary'].get('utility_avg_return', 0):.2f}%")
    
    print("\n🤖 AI Recommendation:")
    recommendation = analyzer.generate_investment_recommendation(results)
    print(recommendation)
    
    print("\n🎯 Top Performers:")
    top_performers = analyzer.screen_top_performers()
    for token in top_performers[:5]:
        print(f"{token['symbol']}: {token['return_30d']:.2f}% ({token['type']})")
    
    return results

# Run analysis
if __name__ == "__main__":
    analysis_results = run_complete_analysis()

def calculate_position_size(self, token_metrics, portfolio_value, max_risk=0.02):
    """Calculate optimal position size based on volatility"""
    
    volatility = token_metrics['volatility'] / 100  # Convert to decimal
    max_drawdown = abs(token_metrics['max_drawdown']) / 100
    
    # Risk-based position sizing
    volatility_risk = min(max_risk / volatility, 0.1)  # Max 10% per position
    drawdown_risk = min(max_risk / max_drawdown, 0.1)
    
    # Use more conservative estimate
    position_risk = min(volatility_risk, drawdown_risk)
    position_value = portfolio_value * position_risk
    
    return {
        'position_size_usd': position_value,
        'portfolio_percentage': position_risk * 100,
        'risk_level': 'HIGH' if position_risk < 0.01 else 'MEDIUM' if position_risk < 0.05 else 'LOW'
    }

def detect_market_regime(self, btc_data):
    """Detect current market regime using AI analysis"""
    
    # Calculate market indicators
    returns = btc_data['close'].pct_change().dropna()
    volatility = returns.std() * (365 ** 0.5)
    recent_return = (btc_data['close'].iloc[-1] / btc_data['close'].iloc[-30] - 1) * 100
    
    regime_prompt = f"""
    Analyze current crypto market regime:
    
    Bitcoin 30-day return: {recent_return:.2f}%
    Annualized volatility: {volatility:.2f}%
    Current price trend: {"Upward" if recent_return > 0 else "Downward"}
    
    Market regimes:
    1. BULL MARKET: Strong uptrend, memecoins outperform
    2. BEAR MARKET: Downtrend, utilities hold value better  
    3. SIDEWAYS: Range-bound, fundamentals matter most
    4. VOLATILE: High uncertainty, risk management critical
    
    Which regime best describes current conditions? Respond with regime name only.
    """
    
    try:
        response = ollama.chat(
            model=self.model,
            messages=[{'role': 'user', 'content': regime_prompt}]
        )
        
        return response['message']['content'].strip().upper()
    except:
        return 'UNCERTAIN'

import schedule
import time

class ContinuousAnalyzer:
    def __init__(self):
        self.analyzer = CryptoPerformanceAnalyzer()
        self.last_analysis = None
    
    def hourly_analysis(self):
        """Run analysis every hour"""
        try:
            print(f"⏰ Running analysis at {datetime.now()}")
            
            # Quick performance check
            memecoins = ['DOGE/USDT', 'SHIB/USDT', 'PEPE/USDT']
            utilities = ['ETH/USDT', 'BNB/USDT', 'LINK/USDT']
            
            results = self.analyzer.compare_categories(memecoins, utilities, days=7)
            
            # Store results for comparison
            self.last_analysis = results
            
            # Generate alerts for significant changes
            self.check_alerts(results)
            
        except Exception as e:
            print(f"Analysis error: {e}")
    
    def check_alerts(self, results):
        """Check for significant performance changes"""
        summary = results['summary']
        
        if 'memecoin_avg_return' in summary and 'utility_avg_return' in summary:
            meme_return = summary['memecoin_avg_return']
            util_return = summary['utility_avg_return']
            
            if abs(meme_return - util_return) > 20:  # 20% difference triggers alert
                winner = "MEMECOINS" if meme_return > util_return else "UTILITIES"
                print(f"🚨 ALERT: {winner} outperforming by {abs(meme_return - util_return):.1f}%")
    
    def start_monitoring(self):
        """Start continuous monitoring"""
        schedule.every().hour.do(self.hourly_analysis)
        schedule.every().day.at("09:00").do(self.daily_report)
        
        print("📈 Starting continuous monitoring...")
        while True:
            schedule.run_pending()
            time.sleep(60)  # Check every minute
    
    def daily_report(self):
        """Generate daily performance report"""
        if self.last_analysis:
            print("\n📋 DAILY PERFORMANCE REPORT")
            print("=" * 40)
            
            summary = self.last_analysis['summary']
            print(f"Memecoin Performance: {summary.get('memecoin_avg_return', 0):.2f}%")
            print(f"Utility Performance: {summary.get('utility_avg_return', 0):.2f}%")
            
            # AI insight
            recommendation = self.analyzer.generate_investment_recommendation(self.last_analysis)
            print(f"\nAI Recommendation:\n{recommendation}")

# Start monitoring
# monitor = ContinuousAnalyzer()
# monitor.start_monitoring()

# Pull specialized financial models
# ollama pull shreyshah/satoshi-7b-q4_k_m  # Bitcoin-focused model
# ollama pull arcee-ai/llama3-sec  # SEC filings analysis

def use_specialized_model(self, analysis_type='general'):
    """Select appropriate model for analysis type"""
    
    model_map = {
        'bitcoin': 'shreyshah/satoshi-7b-q4_k_m',
        'regulatory': 'arcee-ai/llama3-sec',
        'general': 'deepseek-r1:7b'
    }
    
    return model_map.get(analysis_type, 'deepseek-r1:7b')

def backtest_strategy(self, start_date, end_date, rebalance_frequency='weekly'):
    """Backtest memecoin vs utility allocation strategy"""
    
    # Implementation for historical performance testing
    # This would fetch historical data and simulate trading decisions
    pass