Ollama NFT Market Analysis: Collection Valuation and Trend Prediction Guide

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

# Verify installation
ollama --version

# Install code analysis model
ollama pull codellama:7b

# Install general reasoning model  
ollama pull llama2:13b

# Install math and statistics model
ollama pull wizardmath:7b

# requirements.txt
ollama==0.1.7
web3==6.11.0
pandas==2.1.3
numpy==1.24.3
requests==2.31.0
matplotlib==3.7.2
seaborn==0.12.2

pip install -r requirements.txt

import ollama
from web3 import Web3
import pandas as pd
import json

class NFTDataExtractor:
    def __init__(self, rpc_url):
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.ollama_client = ollama.Client()
    
    def get_collection_data(self, contract_address, start_block=None):
        """Extract NFT collection transaction data"""
        # Get contract ABI
        contract = self.w3.eth.contract(
            address=contract_address,
            abi=self.load_erc721_abi()
        )
        
        # Filter transfer events
        transfer_filter = contract.events.Transfer.create_filter(
            fromBlock=start_block or 'earliest'
        )
        
        transfers = []
        for event in transfer_filter.get_all_entries():
            transfers.append({
                'token_id': event.args.tokenId,
                'from_address': event.args['from'],
                'to_address': event.args.to,
                'block_number': event.blockNumber,
                'transaction_hash': event.transactionHash.hex(),
                'timestamp': self.get_block_timestamp(event.blockNumber)
            })
        
        return pd.DataFrame(transfers)
    
    def get_block_timestamp(self, block_number):
        """Get block timestamp for transaction dating"""
        block = self.w3.eth.get_block(block_number)
        return block.timestamp

import requests
import time

class MarketplaceDataCollector:
    def __init__(self):
        self.opensea_api = "https://api.opensea.io/api/v1"
        self.headers = {
            "Accept": "application/json",
            "X-API-KEY": "your_opensea_api_key"
        }
    
    def get_collection_stats(self, collection_slug):
        """Fetch collection statistics from OpenSea"""
        url = f"{self.opensea_api}/collection/{collection_slug}/stats"
        
        response = requests.get(url, headers=self.headers)
        if response.status_code == 200:
            return response.json()['stats']
        else:
            return None
    
    def get_collection_events(self, collection_slug, event_type="sale"):
        """Get collection sale events"""
        url = f"{self.opensea_api}/events"
        params = {
            'collection_slug': collection_slug,
            'event_type': event_type,
            'limit': 300
        }
        
        all_events = []
        
        while True:
            response = requests.get(url, headers=self.headers, params=params)
            
            if response.status_code != 200:
                break
                
            data = response.json()
            events = data.get('asset_events', [])
            
            if not events:
                break
                
            all_events.extend(events)
            
            # Get next page cursor
            if 'cursor' in data:
                params['cursor'] = data['cursor']
            else:
                break
                
            time.sleep(0.2)  # Rate limiting
        
        return all_events

class RarityAnalyzer:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def analyze_trait_rarity(self, collection_metadata):
        """Calculate trait rarity scores using AI analysis"""
        
        # Prepare metadata for AI analysis
        metadata_prompt = f"""
        Analyze this NFT collection metadata and calculate rarity scores:
        
        Collection Data:
        {json.dumps(collection_metadata[:10], indent=2)}
        
        Calculate:
        1. Trait frequency percentages
        2. Rarity multipliers for each trait
        3. Overall rarity score formula
        4. Price prediction based on rarity
        
        Return structured JSON with calculations.
        """
        
        response = self.ollama_client.chat(
            model='codellama:7b',
            messages=[{
                'role': 'user',
                'content': metadata_prompt
            }]
        )
        
        return self.parse_rarity_response(response['message']['content'])
    
    def calculate_fair_value(self, token_metadata, floor_price, rarity_score):
        """Estimate fair value using rarity and market data"""
        
        valuation_prompt = f"""
        Calculate fair value for this NFT:
        
        Token Metadata: {json.dumps(token_metadata)}
        Collection Floor Price: {floor_price} ETH
        Rarity Score: {rarity_score}
        
        Consider:
        - Trait rarity premiums
        - Historical sales patterns
        - Market momentum
        - Aesthetic appeal factors
        
        Provide fair value estimate with confidence interval.
        """
        
        response = self.ollama_client.chat(
            model='wizardmath:7b',
            messages=[{
                'role': 'user', 
                'content': valuation_prompt
            }]
        )
        
        return self.extract_valuation(response['message']['content'])

class SentimentAnalyzer:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def analyze_twitter_sentiment(self, collection_name, tweets_data):
        """Analyze Twitter sentiment for collection"""
        
        sentiment_prompt = f"""
        Analyze sentiment for NFT collection "{collection_name}":
        
        Recent Tweets:
        {self.format_tweets(tweets_data)}
        
        Provide:
        1. Overall sentiment score (-1 to 1)
        2. Key sentiment drivers
        3. Bull/bear ratio
        4. Price impact prediction
        5. Risk factors identified
        
        Focus on trading-relevant insights.
        """
        
        response = self.ollama_client.chat(
            model='llama2:13b',
            messages=[{
                'role': 'user',
                'content': sentiment_prompt
            }]
        )
        
        return self.parse_sentiment_analysis(response['message']['content'])
    
    def analyze_discord_activity(self, discord_messages):
        """Analyze Discord community engagement"""
        
        community_prompt = f"""
        Analyze Discord community health:
        
        Message Sample:
        {self.format_discord_messages(discord_messages)}
        
        Evaluate:
        - Community engagement levels
        - Holder satisfaction
        - Development activity mentions
        - FUD vs positive sentiment
        - Whale holder sentiment
        
        Rate community strength 1-10 with explanations.
        """
        
        response = self.ollama_client.chat(
            model='llama2:13b',
            messages=[{
                'role': 'user',
                'content': community_prompt
            }]
        )
        
        return self.parse_community_analysis(response['message']['content'])

class TrendPredictor:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def predict_price_trends(self, price_history, volume_data, external_factors):
        """Predict short-term price movements"""
        
        prediction_prompt = f"""
        Predict NFT collection price trends:
        
        Price History (last 30 days):
        {self.format_price_data(price_history)}
        
        Volume Data:
        {self.format_volume_data(volume_data)}
        
        External Factors:
        {json.dumps(external_factors)}
        
        Provide:
        1. 7-day price prediction
        2. Confidence intervals
        3. Key resistance/support levels
        4. Volume surge probability
        5. Risk assessment
        
        Use technical analysis principles.
        """
        
        response = self.ollama_client.chat(
            model='wizardmath:7b',
            messages=[{
                'role': 'user',
                'content': prediction_prompt
            }]
        )
        
        return self.parse_price_prediction(response['message']['content'])
    
    def detect_whale_patterns(self, large_transactions):
        """Identify whale buying/selling patterns"""
        
        whale_prompt = f"""
        Analyze whale transaction patterns:
        
        Large Transactions:
        {self.format_whale_data(large_transactions)}
        
        Identify:
        1. Accumulation vs distribution patterns
        2. Whale wallet clustering
        3. Price impact correlations
        4. Future movement signals
        5. Market manipulation risks
        
        Provide actionable trading insights.
        """
        
        response = self.ollama_client.chat(
            model='codellama:7b',
            messages=[{
                'role': 'user',
                'content': whale_prompt
            }]
        )
        
        return self.parse_whale_analysis(response['message']['content'])

class VolumeAnalyzer:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def detect_volume_anomalies(self, volume_data, baseline_period=7):
        """Detect unusual volume spikes"""
        
        volume_prompt = f"""
        Detect volume anomalies in NFT trading:
        
        Recent Volume Data:
        {self.format_volume_timeline(volume_data)}
        
        Baseline Period: {baseline_period} days
        
        Calculate:
        1. Volume spike significance
        2. Organic vs manipulated volume
        3. Price correlation strength
        4. Sustainability probability
        5. Entry/exit recommendations
        
        Provide statistical confidence levels.
        """
        
        response = self.ollama_client.chat(
            model='wizardmath:7b',
            messages=[{
                'role': 'user',
                'content': volume_prompt
            }]
        )
        
        return self.parse_volume_analysis(response['message']['content'])

class RiskAssessment:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def assess_rug_pull_risk(self, project_data):
        """Evaluate project abandonment risk"""
        
        risk_prompt = f"""
        Assess rug pull risk for NFT project:
        
        Project Data:
        - Creator wallet history: {project_data.get('creator_history')}
        - Development activity: {project_data.get('dev_activity')}
        - Community size: {project_data.get('community_metrics')}
        - Roadmap completion: {project_data.get('roadmap_status')}
        - Team transparency: {project_data.get('team_info')}
        
        Red Flags to Check:
        1. Anonymous team members
        2. Unrealistic roadmap promises
        3. Low development activity
        4. Declining community engagement
        5. Unusual founder wallet movements
        
        Rate risk 1-10 with detailed explanation.
        """
        
        response = self.ollama_client.chat(
            model='llama2:13b',
            messages=[{
                'role': 'user',
                'content': risk_prompt
            }]
        )
        
        return self.parse_risk_assessment(response['message']['content'])

class PortfolioManager:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def optimize_nft_portfolio(self, available_collections, budget, risk_tolerance):
        """Create optimized NFT portfolio allocation"""
        
        optimization_prompt = f"""
        Optimize NFT portfolio allocation:
        
        Available Collections:
        {self.format_collection_data(available_collections)}
        
        Investment Parameters:
        - Budget: {budget} ETH
        - Risk Tolerance: {risk_tolerance}/10
        
        Optimize for:
        1. Risk-adjusted returns
        2. Collection diversification
        3. Liquidity requirements
        4. Correlation minimization
        5. Market cycle positioning
        
        Provide specific allocation percentages and reasoning.
        """
        
        response = self.ollama_client.chat(
            model='wizardmath:7b',
            messages=[{
                'role': 'user',
                'content': optimization_prompt
            }]
        )
        
        return self.parse_portfolio_allocation(response['message']['content'])

import matplotlib.pyplot as plt
import seaborn as sns

class PerformanceDashboard:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def generate_performance_report(self, collections_data):
        """Generate comprehensive performance analysis"""
        
        # Create performance visualization
        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
        
        # Plot 1: Price trends
        self.plot_price_trends(axes[0,0], collections_data)
        
        # Plot 2: Volume analysis  
        self.plot_volume_analysis(axes[0,1], collections_data)
        
        # Plot 3: Rarity distribution
        self.plot_rarity_distribution(axes[1,0], collections_data)
        
        # Plot 4: ROI comparison
        self.plot_roi_comparison(axes[1,1], collections_data)
        
        plt.tight_layout()
        plt.savefig('nft_performance_dashboard.png', dpi=300, bbox_inches='tight')
        
        # Generate AI insights
        insights_prompt = f"""
        Analyze NFT portfolio performance:
        
        Collection Data:
        {self.summarize_performance_data(collections_data)}
        
        Provide:
        1. Top performing collections
        2. Underperforming assets
        3. Market correlation analysis
        4. Rebalancing recommendations
        5. Risk exposure assessment
        
        Focus on actionable insights for next 30 days.
        """
        
        response = self.ollama_client.chat(
            model='llama2:13b',
            messages=[{
                'role': 'user',
                'content': insights_prompt
            }]
        )
        
        return {
            'chart_path': 'nft_performance_dashboard.png',
            'ai_insights': response['message']['content']
        }

class CrossChainAnalyzer:
    def __init__(self):
        self.ollama_client = ollama.Client()
        self.supported_chains = ['ethereum', 'polygon', 'solana', 'flow']
    
    def analyze_cross_chain_trends(self, chain_data):
        """Compare NFT trends across different blockchains"""
        
        cross_chain_prompt = f"""
        Analyze NFT market trends across blockchains:
        
        Chain Performance Data:
        {json.dumps(chain_data, indent=2)}
        
        Compare:
        1. Volume migration patterns
        2. Price premium differences
        3. User adoption rates
        4. Gas cost impact on trading
        5. Collection quality differences
        
        Identify arbitrage opportunities and chain-specific trends.
        """
        
        response = self.ollama_client.chat(
            model='llama2:13b',
            messages=[{
                'role': 'user',
                'content': cross_chain_prompt
            }]
        )
        
        return self.parse_cross_chain_analysis(response['message']['content'])

class DataValidator:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def validate_nft_data(self, raw_data):
        """Validate and clean NFT market data"""
        
        validation_prompt = f"""
        Validate NFT market data quality:
        
        Data Sample:
        {json.dumps(raw_data[:5], indent=2)}
        
        Check for:
        1. Missing price data
        2. Duplicate transactions
        3. Wash trading patterns
        4. Outlier sales (potential errors)
        5. Timestamp inconsistencies
        
        Recommend data cleaning steps.
        """
        
        response = self.ollama_client.chat(
            model='codellama:7b',
            messages=[{
                'role': 'user',
                'content': validation_prompt
            }]
        )
        
        return self.apply_data_cleaning(raw_data, response['message']['content'])

class RobustAnalyzer:
    def __init__(self, max_retries=3):
        self.ollama_client = ollama.Client()
        self.max_retries = max_retries
    
    def safe_analysis(self, analysis_function, *args, **kwargs):
        """Wrapper for safe AI analysis with error handling"""
        
        for attempt in range(self.max_retries):
            try:
                result = analysis_function(*args, **kwargs)
                
                # Validate result format
                if self.validate_analysis_result(result):
                    return result
                else:
                    raise ValueError("Invalid analysis result format")
                    
            except Exception as e:
                if attempt == self.max_retries - 1:
                    # Final attempt failed, return fallback analysis
                    return self.fallback_analysis(*args, **kwargs)
                    
                # Wait before retry
                time.sleep(2 ** attempt)
        
        return None

class MarketCycleAdapter:
    def __init__(self):
        self.ollama_client = ollama.Client()
    
    def determine_market_phase(self, market_indicators):
        """Identify current NFT market cycle phase"""
        
        cycle_prompt = f"""
        Determine NFT market cycle phase:
        
        Market Indicators:
        - Total market volume: {market_indicators['volume']}
        - New collection launches: {market_indicators['new_collections']}
        - Average holding periods: {market_indicators['holding_periods']}
        - Celebrity involvement: {market_indicators['celebrity_activity']}
        - Mainstream media coverage: {market_indicators['media_sentiment']}
        
        Classify market phase:
        1. Early Bull (accumulation)
        2. Bull Market (euphoria)
        3. Distribution (smart money exit)
        4. Bear Market (despair)
        5. Recovery (foundation building)
        
        Recommend phase-specific strategies.
        """
        
        response = self.ollama_client.chat(
            model='llama2:13b',
            messages=[{
                'role': 'user',
                'content': cycle_prompt
            }]
        )
        
        return self.parse_market_phase(response['message']['content'])