How to Detect Memecoin Pump Signals with Ollama: Early Entry Strategy Guide

# macOS/Linux
curl -fsSL https://ollama.ai/install.sh | sh

# Windows - Download from ollama.ai

pip install requests pandas numpy tweepy python-telegram-bot web3

ollama pull llama2:13b

# pump_detector.py
import requests
import json
import time
from datetime import datetime
import pandas as pd

class PumpDetector:
    def __init__(self):
        self.ollama_url = "http://localhost:11434/api/generate"
        self.model = "llama2:13b"
        self.signals = []
    
    def query_ollama(self, prompt):
        """Send analysis request to local Ollama instance"""
        payload = {
            "model": self.model,
            "prompt": prompt,
            "stream": False
        }
        
        response = requests.post(self.ollama_url, json=payload)
        return response.json()['response']

def analyze_sentiment(self, tweet_data):
    """Analyze social sentiment for pump indicators"""
    
    prompt = f"""
    Analyze this crypto-related content for pump signals.
    Rate urgency from 1-10 where 10 = immediate pump likely.
    
    Content: {tweet_data}
    
    Look for:
    - Unusual excitement levels
    - FOMO language patterns  
    - Influencer engagement
    - Volume discussion
    - Price prediction claims
    
    Respond with: SCORE: X/10, REASONING: brief explanation
    """
    
    analysis = self.query_ollama(prompt)
    return self.parse_sentiment_score(analysis)

def parse_sentiment_score(self, analysis):
    """Extract numerical score from Ollama response"""
    try:
        score_line = [line for line in analysis.split('\n') 
                     if 'SCORE:' in line][0]
        score = int(score_line.split(':')[1].split('/')[0].strip())
        return min(max(score, 1), 10)  # Clamp between 1-10
    except:
        return 5  # Default neutral score

def analyze_volume_pattern(self, volume_data):
    """Detect unusual volume patterns indicating potential pumps"""
    
    # Calculate volume metrics
    recent_volume = sum(volume_data[-6:])  # Last 6 periods
    historical_avg = sum(volume_data[:-6]) / len(volume_data[:-6])
    volume_ratio = recent_volume / historical_avg
    
    prompt = f"""
    Analyze this volume pattern for pump signals:
    
    Recent 6-period volume: {recent_volume}
    Historical average: {historical_avg:.2f}
    Volume ratio: {volume_ratio:.2f}x
    
    Pattern data: {volume_data}
    
    Evaluate if this indicates an incoming pump.
    Consider: volume accumulation, breakout patterns, whale activity.
    
    Respond with: PUMP_PROBABILITY: X% and key reasons.
    """
    
    analysis = self.query_ollama(prompt)
    return self.extract_probability(analysis)

def monitor_whale_activity(self, wallet_transactions):
    """Analyze large wallet movements for pump coordination"""
    
    large_txs = [tx for tx in wallet_transactions 
                if tx['value'] > 100000]  # $100k+ transactions
    
    if not large_txs:
        return 0
    
    prompt = f"""
    Analyze these large wallet transactions for pump coordination:
    
    {json.dumps(large_txs, indent=2)}
    
    Look for:
    - Multiple large buys in short timeframe
    - Coordinated wallet behavior
    - Exchange deposit/withdrawal patterns
    - Price impact timing
    
    Rate pump coordination likelihood 1-10.
    """
    
    analysis = self.query_ollama(prompt)
    return self.extract_coordination_score(analysis)

def calculate_pump_score(self, signals):
    """Aggregate multiple signals into final pump score"""
    
    weights = {
        'sentiment': 0.3,
        'volume': 0.4, 
        'whale_activity': 0.2,
        'technical': 0.1
    }
    
    weighted_score = sum(signals[key] * weights[key] 
                        for key in weights.keys())
    
    # Apply Ollama final analysis
    prompt = f"""
    Final pump decision analysis:
    
    Sentiment Score: {signals['sentiment']}/10
    Volume Score: {signals['volume']}/10  
    Whale Activity: {signals['whale_activity']}/10
    Technical Score: {signals['technical']}/10
    
    Weighted Average: {weighted_score:.1f}/10
    
    Should we enter this position? Consider:
    - Signal strength combination
    - Market conditions
    - Risk factors
    
    Respond: DECISION: ENTER/WAIT/AVOID with confidence level.
    """
    
    decision = self.query_ollama(prompt)
    return self.parse_entry_decision(decision)

def optimize_entry_timing(self, pump_score, market_data):
    """Determine optimal entry point based on pump signals"""
    
    if pump_score < 6:
        return "WAIT"  # Insufficient signal strength
    
    prompt = f"""
    Entry timing analysis for memecoin pump:
    
    Pump Score: {pump_score}/10
    Current Price: ${market_data['price']}
    24h Volume: ${market_data['volume_24h']}
    Market Cap: ${market_data['market_cap']}
    
    Timing factors:
    - Signal strength is {pump_score}/10
    - Volume trend: {market_data['volume_trend']}
    - Social momentum: {market_data['social_score']}
    
    When should we enter? Consider:
    - Early vs late stage signals
    - Volume confirmation needs
    - Risk of false signals
    
    Respond: TIMING: IMMEDIATE/WAIT_FOR_CONFIRMATION/DOLLAR_COST_AVERAGE
    """
    
    timing_analysis = self.query_ollama(prompt)
    return self.parse_timing_decision(timing_analysis)

def calculate_position_size(self, pump_confidence, account_balance):
    """Calculate appropriate position size based on signal confidence"""
    
    # Base allocation: 1-5% of account based on confidence
    base_allocation = 0.01 + (pump_confidence / 10) * 0.04
    
    prompt = f"""
    Position sizing for memecoin entry:
    
    Signal Confidence: {pump_confidence}/10
    Account Balance: ${account_balance}
    Base Allocation: {base_allocation*100:.1f}%
    
    Risk factors to consider:
    - Memecoin volatility (extremely high)
    - Signal reliability history
    - Current market conditions
    - Maximum acceptable loss
    
    Recommend final position size as percentage of account.
    Consider: This is speculative gambling, not investing.
    
    Respond: POSITION_SIZE: X% with risk justification.
    """
    
    sizing_advice = self.query_ollama(prompt)
    return self.parse_position_size(sizing_advice)

def plan_exit_strategy(self, entry_price, pump_confidence):
    """Create exit plan based on entry conditions"""
    
    prompt = f"""
    Exit strategy for memecoin pump play:
    
    Entry Price: ${entry_price}
    Signal Confidence: {pump_confidence}/10
    
    Plan exits for:
    1. Take profit levels (scale out strategy)
    2. Stop loss protection  
    3. Time-based exits
    4. Signal deterioration exits
    
    Remember: Memecoins can dump 90% in minutes.
    Better to exit early with profit than late with losses.
    
    Respond with specific price levels and conditions.
    """
    
    exit_plan = self.query_ollama(prompt)
    return self.parse_exit_strategy(exit_plan)

def run_detection_cycle(self):
    """Main detection loop - run every 5 minutes"""
    
    print(f"Starting detection cycle at {datetime.now()}")
    
    # Gather data from multiple sources
    social_data = self.fetch_social_signals()
    volume_data = self.fetch_volume_data() 
    whale_data = self.fetch_whale_transactions()
    
    # Run individual analyses
    sentiment_score = self.analyze_sentiment(social_data)
    volume_score = self.analyze_volume_pattern(volume_data)
    whale_score = self.monitor_whale_activity(whale_data)
    
    # Combine signals
    signals = {
        'sentiment': sentiment_score,
        'volume': volume_score,
        'whale_activity': whale_score,
        'technical': self.analyze_technical_patterns()
    }
    
    # Make entry decision
    entry_decision = self.calculate_pump_score(signals)
    
    if entry_decision['action'] == 'ENTER':
        self.execute_entry_strategy(entry_decision)
    
    # Log results
    self.log_detection_results(signals, entry_decision)

def main():
    detector = PumpDetector()
    
    while True:
        try:
            detector.run_detection_cycle()
            time.sleep(300)  # Wait 5 minutes
        except KeyboardInterrupt:
            print("Detection stopped by user")
            break
        except Exception as e:
            print(f"Error in detection cycle: {e}")
            time.sleep(60)  # Wait 1 minute on error

if __name__ == "__main__":
    main()

def train_signal_accuracy(self, historical_data):
    """Use historical performance to improve signal weights"""
    
    prompt = f"""
    Analyze historical pump detection performance:
    
    {json.dumps(historical_data, indent=2)}
    
    Calculate:
    - Which signals were most predictive
    - Optimal weight adjustments
    - False positive patterns to avoid
    - Market condition dependencies
    
    Suggest improved signal weights and filtering rules.
    """
    
    optimization = self.query_ollama(prompt)
    return self.apply_optimizations(optimization)

def multi_timeframe_analysis(self, timeframes=['5m', '15m', '1h', '4h']):
    """Analyze pump signals across multiple timeframes"""
    
    timeframe_signals = {}
    
    for tf in timeframes:
        data = self.fetch_timeframe_data(tf)
        timeframe_signals[tf] = self.analyze_timeframe(data)
    
    prompt = f"""
    Multi-timeframe pump signal analysis:
    
    {json.dumps(timeframe_signals, indent=2)}
    
    Synthesize signals across timeframes:
    - Short-term momentum (5m, 15m)
    - Medium-term trend (1h) 
    - Longer-term context (4h)
    
    Which timeframes align for strongest pump signal?
    Any conflicting signals to consider?
    
    Provide combined confidence score and timing recommendation.
    """
    
    combined_analysis = self.query_ollama(prompt)
    return self.parse_multi_timeframe_result(combined_analysis)

def track_performance_metrics(self):
    """Monitor pump detection accuracy and profitability"""
    
    metrics = self.calculate_performance_metrics()
    
    prompt = f"""
    Pump detection system performance review:
    
    Accuracy Metrics:
    - True Positives: {metrics['true_positives']}
    - False Positives: {metrics['false_positives']}  
    - True Negatives: {metrics['true_negatives']}
    - False Negatives: {metrics['false_negatives']}
    
    Financial Metrics:
    - Profitable Trades: {metrics['profitable_trades']}%
    - Average Return: {metrics['avg_return']}%
    - Maximum Drawdown: {metrics['max_drawdown']}%
    - Sharpe Ratio: {metrics['sharpe_ratio']}
    
    Identify weaknesses and improvement opportunities.
    What adjustments would improve performance?
    """
    
    performance_analysis = self.query_ollama(prompt)
    return self.implement_improvements(performance_analysis)

# Docker containerization
FROM python:3.9-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

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

COPY . .
CMD ["python", "pump_detector.py"]

def setup_webhook_alerts(self):
    """Send alerts to Discord/Telegram when pumps detected"""
    
    def send_alert(signal_data):
        webhook_url = "YOUR_DISCORD_WEBHOOK_URL"
        
        message = f"""
        🚨 PUMP SIGNAL DETECTED 🚨
        
        Token: {signal_data['token']}
        Confidence: {signal_data['confidence']}/10
        Entry Price: ${signal_data['entry_price']}
        
        Signals:
        - Sentiment: {signal_data['sentiment']}/10
        - Volume: {signal_data['volume']}/10  
        - Whale Activity: {signal_data['whale']}/10
        
        Action: {signal_data['action']}
        """
        
        requests.post(webhook_url, {"content": message})

def validate_pump_signal(self, initial_signal):
    """Additional validation to reduce false positives"""
    
    validation_checks = [
        self.check_contract_legitimacy(),
        self.verify_liquidity_depth(), 
        self.analyze_holder_distribution(),
        self.scan_for_rug_pull_patterns()
    ]
    
    prompt = f"""
    Validate pump signal with additional checks:
    
    Initial Signal Strength: {initial_signal}/10
    
    Validation Results:
    - Contract Legitimacy: {validation_checks[0]}
    - Liquidity Depth: {validation_checks[1]}
    - Holder Distribution: {validation_checks[2]}
    - Rug Pull Risk: {validation_checks[3]}
    
    Should we proceed with this signal?
    Any red flags that override the pump indicators?
    
    Final recommendation: PROCEED/CAUTION/ABORT
    """
    
    final_validation = self.query_ollama(prompt)
    return self.parse_validation_result(final_validation)