Ollama Altcoin Screening: Find Hidden Gems in Crypto Markets with AI

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

# Download models optimized for Data Analysis
ollama pull llama2:13b
ollama pull codellama:7b
ollama pull mistral:7b

# requirements.txt
import requests
import pandas as pd
import numpy as np
import json
from datetime import datetime, timedelta
import ollama
import ccxt  # Cryptocurrency exchange library
import yfinance as yf
import tweepy  # Twitter API for sentiment analysis

pip install -r requirements.txt

class AltcoinDataCollector:
    def __init__(self):
        self.exchanges = {
            'binance': ccxt.binance(),
            'coinbase': ccxt.coinbasepro(),
            'kraken': ccxt.kraken()
        }
    
    def get_market_data(self, symbol, timeframe='1d', limit=100):
        """
        Collect OHLCV data from multiple exchanges
        Returns unified dataset with volume and liquidity metrics
        """
        all_data = {}
        
        for exchange_name, exchange in self.exchanges.items():
            try:
                ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
                df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
                df['exchange'] = exchange_name
                all_data[exchange_name] = df
            except Exception as e:
                print(f"Failed to fetch {symbol} from {exchange_name}: {e}")
        
        return all_data
    
    def get_fundamental_data(self, symbol):
        """
        Gather project fundamentals, team info, and tokenomics
        """
        # CoinGecko API for comprehensive project data
        url = f"https://api.coingecko.com/api/v3/coins/{symbol}"
        response = requests.get(url)
        
        if response.status_code == 200:
            data = response.json()
            return {
                'market_cap': data.get('market_data', {}).get('market_cap', {}).get('usd'),
                'total_supply': data.get('market_data', {}).get('total_supply'),
                'circulating_supply': data.get('market_data', {}).get('circulating_supply'),
                'developer_score': data.get('developer_data', {}).get('developer_score'),
                'community_score': data.get('community_data', {}).get('community_score'),
                'description': data.get('description', {}).get('en')
            }
        return None

class SentimentAnalyzer:
    def __init__(self, ollama_model='llama2:13b'):
        self.model = ollama_model
        
    def analyze_social_sentiment(self, symbol, posts_limit=100):
        """
        Analyze sentiment from Twitter, Reddit, and Telegram
        Returns sentiment score and key themes
        """
        social_data = self.collect_social_mentions(symbol, posts_limit)
        
        # Prepare data for Ollama analysis
        combined_text = " ".join([post['text'] for post in social_data])
        
        prompt = f"""
        Analyze the sentiment of these social media posts about {symbol}:
        
        {combined_text[:2000]}  # Limit text to avoid token limits
        
        Provide:
        1. Overall sentiment score (-1 to 1)
        2. Key positive themes
        3. Key negative themes  
        4. Hype vs substance ratio
        5. Community engagement quality
        
        Format as JSON.
        """
        
        response = ollama.generate(model=self.model, prompt=prompt)
        return self.parse_sentiment_response(response['response'])
    
    def parse_sentiment_response(self, response_text):
        """
        Extract structured sentiment data from Ollama response
        """
        try:
            # Ollama responses often need cleaning
            cleaned = response_text.strip()
            if '```json' in cleaned:
                cleaned = cleaned.split('```json')[1].split('```')[0]
            
            return json.loads(cleaned)
        except:
            # Fallback parsing for unstructured responses
            return self.extract_sentiment_manually(response_text)

class OllamaAltcoinScorer:
    def __init__(self):
        self.weights = {
            'technical': 0.3,
            'fundamental': 0.25,
            'sentiment': 0.2,
            'momentum': 0.15,
            'risk': 0.1
        }
    
    def calculate_composite_score(self, coin_data):
        """
        Generate AI-powered composite score for altcoin potential
        Combines technical, fundamental, and sentiment analysis
        """
        scores = {}
        
        # Technical Analysis Score
        scores['technical'] = self.analyze_technical_patterns(coin_data['price_data'])
        
        # Fundamental Analysis Score  
        scores['fundamental'] = self.analyze_fundamentals(coin_data['project_data'])
        
        # Sentiment Analysis Score
        scores['sentiment'] = self.analyze_sentiment_ai(coin_data['social_data'])
        
        # Momentum Score
        scores['momentum'] = self.calculate_momentum_score(coin_data['volume_data'])
        
        # Risk Assessment Score
        scores['risk'] = self.assess_risk_factors(coin_data)
        
        # Calculate weighted composite score
        composite_score = sum(scores[factor] * self.weights[factor] for factor in scores)
        
        return {
            'composite_score': composite_score,
            'factor_scores': scores,
            'recommendation': self.generate_recommendation(composite_score, scores)
        }
    
    def analyze_technical_patterns(self, price_data):
        """
        Use Ollama to identify bullish/bearish technical patterns
        """
        # Convert price data to text description for AI analysis
        pattern_description = self.describe_price_patterns(price_data)
        
        prompt = f"""
        Analyze these technical patterns for potential breakout signals:
        
        {pattern_description}
        
        Score from 0-100 based on:
        - Support/resistance levels
        - Volume confirmation
        - Trend strength
        - Breakout probability
        
        Return only the numeric score.
        """
        
        response = ollama.generate(model='llama2:13b', prompt=prompt)
        return self.extract_numeric_score(response['response'])

class HiddenGemDetector:
    def __init__(self):
        self.gem_criteria = {
            'max_market_cap': 100_000_000,  # Under $100M market cap
            'min_volume_24h': 1_000_000,    # At least $1M daily volume
            'max_age_days': 730,            # Less than 2 years old
            'min_holder_growth': 0.15       # 15% holder growth monthly
        }
    
    def scan_for_hidden_gems(self, coin_list):
        """
        Scan large coin list for hidden gems using AI analysis
        Returns ranked list of potential gems
        """
        potential_gems = []
        
        for coin in coin_list:
            # Quick filter using basic criteria
            if not self.meets_basic_criteria(coin):
                continue
            
            # Deep AI analysis for qualifying coins
            ai_analysis = self.deep_analysis_with_ollama(coin)
            
            if ai_analysis['gem_probability'] > 0.7:
                potential_gems.append({
                    'symbol': coin['symbol'],
                    'gem_score': ai_analysis['gem_probability'],
                    'reasoning': ai_analysis['reasoning'],
                    'risk_factors': ai_analysis['risks']
                })
        
        # Sort by gem score descending
        return sorted(potential_gems, key=lambda x: x['gem_score'], reverse=True)
    
    def deep_analysis_with_ollama(self, coin_data):
        """
        Comprehensive AI analysis to identify gem potential
        """
        analysis_prompt = f"""
        Evaluate this altcoin for "hidden gem" potential:
        
        Coin: {coin_data['name']} ({coin_data['symbol']})
        Market Cap: ${coin_data['market_cap']:,}
        Volume 24h: ${coin_data['volume_24h']:,}
        Price Change 7d: {coin_data['price_change_7d']}%
        
        Project Description: {coin_data['description'][:500]}
        
        Team Background: {coin_data['team_info']}
        
        Recent Developments: {coin_data['recent_news']}
        
        Rate gem potential (0-1) considering:
        1. Unique value proposition
        2. Market undervaluation
        3. Team execution capability  
        4. Competitive advantages
        5. Growth catalyst potential
        
        Provide JSON response with gem_probability, reasoning, and risk_factors.
        """
        
        response = ollama.generate(model='mistral:7b', prompt=analysis_prompt)
        return self.parse_gem_analysis(response['response'])

class RiskManager:
    def __init__(self):
        self.risk_thresholds = {
            'max_position_size': 0.05,      # 5% max per position
            'correlation_limit': 0.7,       # Max correlation between holdings
            'volatility_limit': 2.0,        # Max volatility vs Bitcoin
            'liquidity_minimum': 100000     # Minimum daily volume
        }
    
    def assess_portfolio_risk(self, current_holdings, new_coin):
        """
        Analyze risk of adding new altcoin to existing portfolio
        """
        risk_prompt = f"""
        Portfolio Risk Analysis:
        
        Current Holdings: {[coin['symbol'] for coin in current_holdings]}
        Proposed Addition: {new_coin['symbol']}
        
        Current Portfolio Value: ${sum(coin['value'] for coin in current_holdings):,}
        Proposed Position Size: ${new_coin['proposed_investment']:,}
        
        Analyze risks:
        1. Correlation with existing holdings
        2. Sector concentration risk
        3. Liquidity risk
        4. Volatility impact on portfolio
        5. Overall portfolio balance
        
        Recommend position size and provide risk score (0-100).
        Format as JSON with risk_score, recommended_size, and warnings.
        """
        
        response = ollama.generate(model='llama2:13b', prompt=risk_prompt)
        return self.parse_risk_assessment(response['response'])
    
    def generate_exit_strategy(self, position_data):
        """
        Create AI-powered exit strategy based on position performance
        """
        exit_prompt = f"""
        Generate exit strategy for this position:
        
        Coin: {position_data['symbol']}
        Entry Price: ${position_data['entry_price']}
        Current Price: ${position_data['current_price']}
        Position Size: {position_data['quantity']} tokens
        Days Held: {position_data['days_held']}
        
        Current P&L: {position_data['pnl_percentage']:.2f}%
        
        Market Conditions: {position_data['market_sentiment']}
        Recent News: {position_data['recent_developments']}
        
        Recommend:
        1. Hold/Sell/Reduce decision
        2. Target exit prices
        3. Stop-loss levels
        4. Timeline for reassessment
        
        Provide reasoning and specific action steps.
        """
        
        response = ollama.generate(model='mistral:7b', prompt=exit_prompt)
        return self.parse_exit_strategy(response['response'])

class DailyScreener:
    def __init__(self):
        self.screener = OllamaAltcoinScorer()
        self.detector = HiddenGemDetector()
        self.risk_manager = RiskManager()
    
    def run_daily_scan(self):
        """
        Complete daily altcoin screening process
        """
        print("Starting daily altcoin scan...")
        
        # Get top 500 coins by market cap
        coin_list = self.fetch_top_coins(500)
        
        # Filter for screening candidates
        candidates = self.filter_candidates(coin_list)
        
        # Run AI analysis on each candidate
        results = []
        for coin in candidates:
            try:
                score = self.screener.calculate_composite_score(coin)
                if score['composite_score'] > 70:  # High potential threshold
                    results.append({
                        'coin': coin['symbol'],
                        'score': score,
                        'timestamp': datetime.now()
                    })
            except Exception as e:
                print(f"Error analyzing {coin['symbol']}: {e}")
        
        # Generate daily report
        self.generate_daily_report(results)
        return results
    
    def generate_daily_report(self, scan_results):
        """
        Create comprehensive daily report with AI insights
        """
        report_prompt = f"""
        Generate a professional altcoin screening report for today:
        
        Scan Results: {len(scan_results)} high-potential coins identified
        
        Top Performers:
        {self.format_top_results(scan_results[:5])}
        
        Market Conditions: {self.get_market_overview()}
        
        Create a report including:
        1. Executive summary
        2. Top 3 recommendations with rationale
        3. Market outlook
        4. Risk warnings
        5. Action items for investors
        
        Professional tone, specific insights, actionable advice.
        """
        
        response = ollama.generate(model='llama2:13b', prompt=report_prompt)
        
        # Save report and optionally send via email/Slack
        self.save_report(response['response'])
        return response['response']

def integrate_with_portfolio(screening_results, current_portfolio):
    """
    Automatically integrate new opportunities with existing portfolio
    """
    integration_prompt = f"""
    Portfolio Integration Analysis:
    
    Current Portfolio:
    {format_portfolio_summary(current_portfolio)}
    
    New Opportunities from Screening:
    {format_screening_results(screening_results)}
    
    Portfolio Constraints:
    - Maximum 15 positions
    - No more than 20% in any sector
    - Maintain 10% cash buffer
    - Target risk-adjusted returns
    
    Recommend:
    1. Which new positions to add
    2. Existing positions to trim/exit
    3. Optimal position sizing
    4. Rebalancing schedule
    5. Risk mitigation steps
    
    Provide specific buy/sell orders and reasoning.
    """
    
    response = ollama.generate(model='mistral:7b', prompt=integration_prompt)
    return parse_integration_recommendations(response['response'])

def create_crypto_training_data():
    """
    Generate training data from historical successful trades
    """
    training_examples = []
    
    # Collect historical data for coins that performed well
    successful_trades = load_historical_winners()
    
    for trade in successful_trades:
        example = {
            'input': format_coin_analysis_input(trade['coin_data']),
            'output': format_successful_outcome(trade['results'])
        }
        training_examples.append(example)
    
    return training_examples

def fine_tune_ollama_model(training_data):
    """
    Fine-tune Ollama model for improved crypto analysis
    """
    # Save training data in Ollama format
    with open('crypto_training.jsonl', 'w') as f:
        for example in training_data:
            f.write(json.dumps(example) + '\n')
    
    # Fine-tune command (adjust based on your setup)
    subprocess.run([
        'ollama', 'create', 'crypto-analyst',
        '-f', 'crypto_training.jsonl'
    ])

class PerformanceTracker:
    def __init__(self):
        self.trades_db = []
        
    def track_recommendation_performance(self, recommendation, actual_outcome):
        """
        Monitor how well AI recommendations perform in practice
        """
        performance_data = {
            'recommendation_date': recommendation['date'],
            'coin': recommendation['symbol'],
            'ai_score': recommendation['composite_score'],
            'recommended_action': recommendation['action'],
            'actual_return_7d': actual_outcome['return_7d'],
            'actual_return_30d': actual_outcome['return_30d'],
            'max_drawdown': actual_outcome['max_drawdown']
        }
        
        self.trades_db.append(performance_data)
        
        # Analyze patterns in successful vs failed recommendations
        self.analyze_success_patterns()
    
    def analyze_success_patterns(self):
        """
        Use AI to identify patterns in successful recommendations
        """
        if len(self.trades_db) < 20:  # Need minimum data for analysis
            return
        
        successful_trades = [t for t in self.trades_db if t['actual_return_30d'] > 0.1]
        failed_trades = [t for t in self.trades_db if t['actual_return_30d'] < -0.05]
        
        pattern_prompt = f"""
        Analyze patterns in successful vs failed altcoin recommendations:
        
        Successful Trades ({len(successful_trades)}):
        {self.format_trade_summary(successful_trades)}
        
        Failed Trades ({len(failed_trades)}):
        {self.format_trade_summary(failed_trades)}
        
        Identify:
        1. Common characteristics of successful picks
        2. Warning signs in failed recommendations  
        3. Optimal AI score thresholds
        4. Market condition dependencies
        5. Improvements for screening algorithm
        
        Provide actionable insights for better performance.
        """
        
        response = ollama.generate(model='llama2:13b', prompt=pattern_prompt)
        return self.parse_performance_insights(response['response'])

# Improved prompt engineering
def create_structured_prompt(coin_data):
    return f"""
    ROLE: You are a professional cryptocurrency analyst with 10+ years of experience.
    
    TASK: Analyze {coin_data['symbol']} for investment potential.
    
    DATA:
    Market Cap: ${coin_data['market_cap']:,}
    Volume 24h: ${coin_data['volume']:,}
    Price Change 7d: {coin_data['price_change']}%
    
    ANALYSIS FRAMEWORK:
    1. Technology Assessment (0-25 points)
    2. Team & Partnerships (0-25 points)  
    3. Market Position (0-25 points)
    4. Risk Factors (0-25 points)
    
    REQUIRED OUTPUT FORMAT:
    {{
        "total_score": [0-100],
        "technology_score": [0-25],
        "team_score": [0-25],
        "market_score": [0-25], 
        "risk_score": [0-25],
        "summary": "[2-3 sentence summary]",
        "recommendation": "[BUY/HOLD/SELL]"
    }}
    
    CONSTRAINTS:
    - Provide only the JSON response
    - Be specific and data-driven
    - Consider current market conditions
    """

def validate_coin_data(coin_data):
    """
    Ensure data quality before AI analysis
    """
    required_fields = ['market_cap', 'volume_24h', 'price', 'symbol']
    
    for field in required_fields:
        if field not in coin_data or coin_data[field] is None:
            raise ValueError(f"Missing required field: {field}")
    
    # Sanity checks
    if coin_data['market_cap'] <= 0:
        raise ValueError("Invalid market cap")
    
    if coin_data['volume_24h'] < 1000:  # Minimum liquidity threshold
        raise ValueError("Insufficient trading volume")
    
    return True