How to Create AI Agent Income Stream with Ollama: Rental and Revenue Optimization Guide

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

# Configure for network access
sudo systemctl edit ollama

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_MODELS=/opt/ollama/models"
Environment="OLLAMA_MAX_LOADED_MODELS=4"

sudo systemctl restart ollama
sudo systemctl enable ollama

# High-demand general purpose model
ollama pull llama3:8b

# Coding-focused model for developer clients
ollama pull codellama:7b

# Lightweight model for basic tasks
ollama pull phi3:3.8b

# Specialized model for creative writing
ollama pull mistral:7b

# app.py - AI Agent Rental Management System
from flask import Flask, request, jsonify
import requests
import sqlite3
import hashlib
import time
from datetime import datetime, timedelta

app = Flask(__name__)

# Initialize database
def init_db():
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    # Users table
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY,
            api_key TEXT UNIQUE,
            email TEXT,
            tier TEXT DEFAULT 'basic',
            credits INTEGER DEFAULT 1000,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    ''')
    
    # Usage tracking table
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS usage (
            id INTEGER PRIMARY KEY,
            user_id INTEGER,
            model_name TEXT,
            tokens_used INTEGER,
            cost REAL,
            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            FOREIGN KEY (user_id) REFERENCES users (id)
        )
    ''')
    
    conn.commit()
    conn.close()

# Generate API key for new users
def generate_api_key(email):
    return hashlib.sha256(f"{email}{time.time()}".encode()).hexdigest()[:32]

# Validate user and check credits
def validate_request(api_key):
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    cursor.execute('SELECT id, credits, tier FROM users WHERE api_key = ?', (api_key,))
    user = cursor.fetchone()
    conn.close()
    
    return user

# Track usage and deduct credits
def track_usage(user_id, model_name, tokens, cost):
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    # Record usage
    cursor.execute('''
        INSERT INTO usage (user_id, model_name, tokens_used, cost)
        VALUES (?, ?, ?, ?)
    ''', (user_id, model_name, tokens, cost))
    
    # Deduct credits
    cursor.execute('UPDATE users SET credits = credits - ? WHERE id = ?', (cost, user_id))
    
    conn.commit()
    conn.close()

@app.route('/api/chat', methods=['POST'])
def ai_chat():
    # Get API key from headers
    api_key = request.headers.get('X-API-Key')
    if not api_key:
        return jsonify({'error': 'API key required'}), 401
    
    # Validate user
    user = validate_request(api_key)
    if not user:
        return jsonify({'error': 'Invalid API key'}), 401
    
    user_id, credits, tier = user
    if credits <= 0:
        return jsonify({'error': 'Insufficient credits'}), 402
    
    # Get request data
    data = request.json
    model = data.get('model', 'phi3:3.8b')
    prompt = data.get('prompt', '')
    
    # Check model access based on tier
    tier_models = {
        'basic': ['phi3:3.8b'],
        'premium': ['phi3:3.8b', 'llama3:8b', 'mistral:7b'],
        'enterprise': ['phi3:3.8b', 'llama3:8b', 'mistral:7b', 'codellama:7b']
    }
    
    if model not in tier_models.get(tier, []):
        return jsonify({'error': f'Model {model} not available for {tier} tier'}), 403
    
    # Forward request to Ollama
    try:
        ollama_response = requests.post('http://localhost:11434/api/generate', json={
            'model': model,
            'prompt': prompt,
            'stream': False
        })
        
        if ollama_response.status_code == 200:
            result = ollama_response.json()
            
            # Calculate cost (example: 1 credit per 100 tokens)
            tokens_used = len(result.get('response', '').split())
            cost = max(1, tokens_used // 100)
            
            # Track usage
            track_usage(user_id, model, tokens_used, cost)
            
            return jsonify({
                'response': result.get('response'),
                'model': model,
                'tokens_used': tokens_used,
                'credits_remaining': credits - cost
            })
        else:
            return jsonify({'error': 'AI service unavailable'}), 503
            
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/api/register', methods=['POST'])
def register_user():
    data = request.json
    email = data.get('email')
    tier = data.get('tier', 'basic')
    
    if not email:
        return jsonify({'error': 'Email required'}), 400
    
    api_key = generate_api_key(email)
    
    # Set initial credits based on tier
    initial_credits = {
        'basic': 1000,
        'premium': 5000,
        'enterprise': 20000
    }
    
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    try:
        cursor.execute('''
            INSERT INTO users (api_key, email, tier, credits)
            VALUES (?, ?, ?, ?)
        ''', (api_key, email, tier, initial_credits.get(tier, 1000)))
        
        conn.commit()
        return jsonify({
            'api_key': api_key,
            'tier': tier,
            'credits': initial_credits.get(tier, 1000)
        })
        
    except sqlite3.IntegrityError:
        return jsonify({'error': 'Email already registered'}), 409
    finally:
        conn.close()

if __name__ == '__main__':
    init_db()
    app.run(host='0.0.0.0', port=5000, debug=False)

# monitor.py - Revenue and Performance Monitoring
import sqlite3
import psutil
import time
from datetime import datetime, timedelta

def get_daily_revenue():
    """Calculate revenue for the last 24 hours"""
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    yesterday = datetime.now() - timedelta(days=1)
    
    cursor.execute('''
        SELECT SUM(cost) FROM usage 
        WHERE timestamp > ?
    ''', (yesterday,))
    
    revenue = cursor.fetchone()[0] or 0
    conn.close()
    
    return revenue

def get_active_users():
    """Count users who made requests in the last hour"""
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    hour_ago = datetime.now() - timedelta(hours=1)
    
    cursor.execute('''
        SELECT COUNT(DISTINCT user_id) FROM usage 
        WHERE timestamp > ?
    ''', (hour_ago,))
    
    active_users = cursor.fetchone()[0] or 0
    conn.close()
    
    return active_users

def check_system_health():
    """Monitor system resources"""
    cpu_usage = psutil.cpu_percent(interval=1)
    memory = psutil.virtual_memory()
    disk = psutil.disk_usage('/')
    
    return {
        'cpu_percent': cpu_usage,
        'memory_percent': memory.percent,
        'disk_percent': disk.percent,
        'memory_available_gb': memory.available / (1024**3)
    }

def generate_report():
    """Generate daily performance report"""
    revenue = get_daily_revenue()
    active_users = get_active_users()
    system_health = check_system_health()
    
    print(f"\n=== AI Rental Service Report - {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
    print(f"Daily Revenue: ${revenue * 0.01:.2f}")  # Assuming 1 credit = $0.01
    print(f"Active Users (last hour): {active_users}")
    print(f"CPU Usage: {system_health['cpu_percent']:.1f}%")
    print(f"Memory Usage: {system_health['memory_percent']:.1f}%")
    print(f"Available Memory: {system_health['memory_available_gb']:.1f} GB")
    print(f"Disk Usage: {system_health['disk_percent']:.1f}%")
    
    # Alert conditions
    if system_health['cpu_percent'] > 80:
        print("⚠️  WARNING: High CPU usage detected")
    
    if system_health['memory_percent'] > 85:
        print("⚠️  WARNING: High memory usage detected")
    
    if revenue == 0:
        print("⚠️  NOTICE: No revenue generated in last 24 hours")

if __name__ == '__main__':
    generate_report()

# pricing.py - Dynamic Pricing System
from datetime import datetime
import sqlite3

def get_current_load():
    """Calculate current system load based on active requests"""
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    # Count requests in last 5 minutes
    five_min_ago = datetime.now() - timedelta(minutes=5)
    cursor.execute('SELECT COUNT(*) FROM usage WHERE timestamp > ?', (five_min_ago,))
    
    recent_requests = cursor.fetchone()[0]
    conn.close()
    
    return recent_requests

def calculate_dynamic_price(base_cost, model_name):
    """Adjust pricing based on current demand and model complexity"""
    
    # Model complexity multipliers
    model_multipliers = {
        'phi3:3.8b': 1.0,
        'llama3:8b': 1.5,
        'mistral:7b': 1.3,
        'codellama:7b': 1.8
    }
    
    # Time-based pricing (peak hours cost more)
    current_hour = datetime.now().hour
    if 9 <= current_hour <= 17:  # Business hours
        time_multiplier = 1.2
    elif 18 <= current_hour <= 22:  # Evening peak
        time_multiplier = 1.1
    else:  # Off-peak
        time_multiplier = 0.9
    
    # Load-based pricing
    current_load = get_current_load()
    if current_load > 50:  # High load
        load_multiplier = 1.3
    elif current_load > 20:  # Medium load
        load_multiplier = 1.1
    else:  # Low load
        load_multiplier = 1.0
    
    final_cost = base_cost * model_multipliers.get(model_name, 1.0) * time_multiplier * load_multiplier
    
    return max(1, int(final_cost))  # Minimum 1 credit

# referrals.py - Customer Acquisition System
def create_referral_code(user_id):
    """Generate unique referral code for user"""
    import hashlib
    code = hashlib.md5(f"ref_{user_id}_{time.time()}".encode()).hexdigest()[:8]
    
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    cursor.execute('''
        INSERT OR REPLACE INTO referrals (user_id, code, credits_earned)
        VALUES (?, ?, 0)
    ''', (user_id, code))
    
    conn.commit()
    conn.close()
    
    return code

def process_referral(referral_code, new_user_email):
    """Award credits when referral signs up"""
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    # Find referrer
    cursor.execute('SELECT user_id FROM referrals WHERE code = ?', (referral_code,))
    referrer = cursor.fetchone()
    
    if referrer:
        referrer_id = referrer[0]
        
        # Award bonus credits to referrer
        cursor.execute('UPDATE users SET credits = credits + 500 WHERE id = ?', (referrer_id,))
        
        # Award bonus credits to new user
        cursor.execute('UPDATE users SET credits = credits + 200 WHERE email = ?', (new_user_email,))
        
        # Update referral stats
        cursor.execute('UPDATE referrals SET credits_earned = credits_earned + 500 WHERE code = ?', (referral_code,))
        
        conn.commit()
    
    conn.close()

# docker-compose.yml for scalable deployment
version: '3.8'
services:
  ollama-1:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ./models:/root/.ollama
    environment:
      - OLLAMA_MAX_LOADED_MODELS=2
  
  ollama-2:
    image: ollama/ollama
    ports:
      - "11435:11434"
    volumes:
      - ./models:/root/.ollama
    environment:
      - OLLAMA_MAX_LOADED_MODELS=2
  
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf

# nginx.conf - Load Balancer Configuration
upstream ollama_backend {
    server localhost:11434;
    server localhost:11435;
}

server {
    listen 80;
    
    location /api/ {
        proxy_pass http://ollama_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

# billing.py - Automated Payment Processing
import stripe
import sqlite3
from datetime import datetime, timedelta

stripe.api_key = "your_stripe_secret_key"

def create_subscription(user_email, tier):
    """Create Stripe subscription for user"""
    
    price_ids = {
        'basic': 'price_basic_monthly',
        'premium': 'price_premium_monthly', 
        'enterprise': 'price_enterprise_monthly'
    }
    
    customer = stripe.Customer.create(email=user_email)
    
    subscription = stripe.Subscription.create(
        customer=customer.id,
        items=[{'price': price_ids[tier]}],
        payment_behavior='default_incomplete',
        expand=['latest_invoice.payment_intent'],
    )
    
    return subscription

def handle_successful_payment(user_email, tier):
    """Add credits when payment succeeds"""
    
    credit_amounts = {
        'basic': 1000,
        'premium': 5000,
        'enterprise': 20000
    }
    
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    cursor.execute('''
        UPDATE users SET credits = credits + ? 
        WHERE email = ?
    ''', (credit_amounts[tier], user_email))
    
    conn.commit()
    conn.close()

# optimization.py - Automatic Resource Management
import psutil
import subprocess
import time

def optimize_ollama_performance():
    """Automatically adjust Ollama settings based on system load"""
    
    # Get current system stats
    cpu_percent = psutil.cpu_percent(interval=1)
    memory = psutil.virtual_memory()
    
    # Adjust max loaded models based on available memory
    available_gb = memory.available / (1024**3)
    
    if available_gb > 16:
        max_models = 4
    elif available_gb > 8:
        max_models = 2
    else:
        max_models = 1
    
    # Update Ollama configuration
    with open('/etc/systemd/system/ollama.service.d/override.conf', 'w') as f:
        f.write(f"""[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_MAX_LOADED_MODELS={max_models}"
""")
    
    subprocess.run(['sudo', 'systemctl', 'restart', 'ollama'])
    
    print(f"Optimized: Set max models to {max_models} (Available RAM: {available_gb:.1f}GB)")

def cleanup_unused_models():
    """Remove models that haven't been used recently"""
    
    conn = sqlite3.connect('ai_rental.db')
    cursor = conn.cursor()
    
    # Find models not used in last 7 days
    week_ago = datetime.now() - timedelta(days=7)
    cursor.execute('''
        SELECT DISTINCT model_name FROM usage 
        WHERE timestamp > ?
    ''', (week_ago,))
    
    active_models = [row[0] for row in cursor.fetchall()]
    conn.close()
    
    # Get all installed models
    result = subprocess.run(['ollama', 'list'], capture_output=True, text=True)
    installed_models = []
    
    for line in result.stdout.split('\n')[1:]:  # Skip header
        if line.strip():
            model_name = line.split()[0]
            installed_models.append(model_name)
    
    # Remove unused models
    for model in installed_models:
        if model not in active_models:
            subprocess.run(['ollama', 'rm', model])
            print(f"Removed unused model: {model}")

if __name__ == '__main__':
    optimize_ollama_performance()
    cleanup_unused_models()

# analytics.py - Revenue Analytics Dashboard
import sqlite3
import matplotlib.pyplot as plt
from datetime import datetime, timedelta
import pandas as pd

def generate_revenue_report(days=30):
    """Generate comprehensive revenue analysis"""
    
    conn = sqlite3.connect('ai_rental.db')
    
    # Daily revenue over time
    query = '''
        SELECT DATE(timestamp) as date, 
               SUM(cost) as daily_revenue,
               COUNT(*) as requests,
               COUNT(DISTINCT user_id) as active_users
        FROM usage 
        WHERE timestamp > datetime('now', '-{} days')
        GROUP BY DATE(timestamp)
        ORDER BY date
    '''.format(days)
    
    df = pd.read_sql_query(query, conn)
    
    # Model popularity
    model_query = '''
        SELECT model_name, 
               COUNT(*) as usage_count,
               SUM(cost) as total_revenue
        FROM usage 
        WHERE timestamp > datetime('now', '-{} days')
        GROUP BY model_name
        ORDER BY total_revenue DESC
    '''.format(days)
    
    model_df = pd.read_sql_query(model_query, conn)
    
    # User tier analysis
    tier_query = '''
        SELECT u.tier,
               COUNT(DISTINCT u.id) as user_count,
               SUM(usage.cost) as total_revenue,
               AVG(usage.cost) as avg_revenue_per_user
        FROM users u
        LEFT JOIN usage ON u.id = usage.user_id
        WHERE usage.timestamp > datetime('now', '-{} days')
        GROUP BY u.tier
    '''.format(days)
    
    tier_df = pd.read_sql_query(tier_query, conn)
    conn.close()
    
    # Generate visualizations
    fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
    
    # Daily revenue trend
    ax1.plot(pd.to_datetime(df['date']), df['daily_revenue'])
    ax1.set_title('Daily Revenue Trend')
    ax1.set_ylabel('Revenue (Credits)')
    
    # Model popularity
    ax2.bar(model_df['model_name'], model_df['total_revenue'])
    ax2.set_title('Revenue by Model')
    ax2.set_ylabel('Revenue (Credits)')
    ax2.tick_params(axis='x', rotation=45)
    
    # Active users over time
    ax3.plot(pd.to_datetime(df['date']), df['active_users'])
    ax3.set_title('Daily Active Users')
    ax3.set_ylabel('Users')
    
    # Revenue by tier
    ax4.pie(tier_df['total_revenue'], labels=tier_df['tier'], autopct='%1.1f%%')
    ax4.set_title('Revenue Distribution by Tier')
    
    plt.tight_layout()
    plt.savefig('revenue_analytics.png', dpi=300, bbox_inches='tight')
    
    # Calculate key metrics
    total_revenue = df['daily_revenue'].sum()
    avg_daily_revenue = df['daily_revenue'].mean()
    total_requests = df['requests'].sum()
    avg_revenue_per_request = total_revenue / total_requests if total_requests > 0 else 0
    
    print(f"\n=== {days}-Day Revenue Analytics ===")
    print(f"Total Revenue: {total_revenue} credits (${total_revenue * 0.01:.2f})")
    print(f"Average Daily Revenue: {avg_daily_revenue:.1f} credits")
    print(f"Total Requests: {total_requests}")
    print(f"Revenue per Request: {avg_revenue_per_request:.2f} credits")
    print(f"Most Popular Model: {model_df.iloc[0]['model_name']}")
    print(f"Highest Revenue Tier: {tier_df.loc[tier_df['total_revenue'].idxmax(), 'tier']}")

if __name__ == '__main__':
    generate_revenue_report()

# security_setup.sh - Production Security Configuration
#!/bin/bash

# Create dedicated user for AI service
sudo useradd -m -s /bin/bash aiservice
sudo usermod -aG docker aiservice

# Set up SSL certificates with Let's Encrypt
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d yourdomain.com

# Configure firewall
sudo ufw enable
sudo ufw allow ssh
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 5000/tcp  # API gateway

# Set up log rotation
sudo tee /etc/logrotate.d/aiservice << EOF
/home/aiservice/logs/*.log {
    daily
    rotate 30
    compress
    delaycompress
    missingok
    notifempty
    create 644 aiservice aiservice
}
EOF

# Create systemd service for API gateway
sudo tee /etc/systemd/system/ai-rental-api.service << EOF
[Unit]
Description=AI Rental API Gateway
After=network.target

[Service]
Type=simple
User=aiservice
WorkingDirectory=/home/aiservice/ai-rental
ExecStart=/usr/bin/python3 app.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable ai-rental-api
sudo systemctl start ai-rental-api

# backup.py - Automated Backup System
import sqlite3
import shutil
import boto3
import os
from datetime import datetime

def backup_database():
    """Create timestamped database backup"""
    
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    backup_filename = f'ai_rental_backup_{timestamp}.db'
    
    # Create local backup
    shutil.copy2('ai_rental.db', f'backups/{backup_filename}')
    
    # Upload to S3 (optional)
    if os.environ.get('AWS_ACCESS_KEY_ID'):
        s3 = boto3.client('s3')
        s3.upload_file(
            f'backups/{backup_filename}',
            'your-backup-bucket',
            f'database-backups/{backup_filename}'
        )
    
    print(f"Database backed up: {backup_filename}")

def cleanup_old_backups(days_to_keep=30):
    """Remove backup files older than specified days"""
    
    cutoff_date = datetime.now() - timedelta(days=days_to_keep)
    
    for filename in os.listdir('backups'):
        if filename.startswith('ai_rental_backup_'):
            file_path = os.path.join('backups', filename)
            file_date = datetime.fromtimestamp(os.path.getctime(file_path))
            
            if file_date < cutoff_date:
                os.remove(file_path)
                print(f"Removed old backup: {filename}")

if __name__ == '__main__':
    os.makedirs('backups', exist_ok=True)
    backup_database()
    cleanup_old_backups()