5G Edge AI: Build Lightning-Fast Ollama Mobile Apps with Edge Computing

# Minimum edge node specifications
CPU: 8 cores ARM64 or x86_64
RAM: 32GB (16GB for models, 16GB for system)
Storage: 1TB NVMe SSD
Network: 5G SA (Standalone) connection
GPU: Optional - NVIDIA Jetson or similar edge GPU

#!/bin/bash
# Install Ollama for edge deployment
curl -fsSL https://ollama.ai/install.sh | sh

# Configure for edge use
sudo systemctl enable ollama
sudo systemctl start ollama

# Set resource limits for edge environment
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_MAX_LOADED_MODELS=2
export OLLAMA_FLASH_ATTENTION=1
export OLLAMA_NUM_PARALLEL=4

# Model performance comparison for edge deployment
edge_models = {
    'llama3.2-3b': {
        'memory': '6GB',
        'inference_time': '45ms',
        'quality': 'good'
    },
    'phi3-mini': {
        'memory': '4GB', 
        'inference_time': '35ms',
        'quality': 'moderate'
    },
    'gemma2-2b': {
        'memory': '3GB',
        'inference_time': '30ms', 
        'quality': 'good'
    }
}

def select_optimal_model(memory_limit, latency_requirement):
    """Select best model for edge constraints"""
    suitable_models = []
    
    for model, specs in edge_models.items():
        memory_gb = int(specs['memory'].replace('GB', ''))
        latency_ms = int(specs['inference_time'].replace('ms', ''))
        
        if memory_gb <= memory_limit and latency_ms <= latency_requirement:
            suitable_models.append((model, specs))
    
    return sorted(suitable_models, key=lambda x: x[1]['quality'], reverse=True)

# Example: Select model for 8GB memory, 50ms latency
best_model = select_optimal_model(8, 50)
print(f"Recommended model: {best_model[0]}")

# Download and quantize model for edge deployment
ollama pull llama3.2-3b
ollama create llama3.2-3b-q4 -f - <<EOF
FROM llama3.2-3b
PARAMETER num_ctx 2048
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.1
EOF

# Verify quantized model size
ollama list | grep llama3.2-3b

// EdgeAIClient.js - React Native edge AI client
import AsyncStorage from '@react-native-async-storage/async-storage';

class EdgeAIClient {
  constructor() {
    this.edgeNodes = [];
    this.activeNode = null;
    this.failoverEnabled = true;
  }

  async discoverEdgeNodes() {
    // Discover nearby edge nodes using network scanning
    const discoveredNodes = await this.scanNetworkForEdgeNodes();
    
    // Test latency to each node
    const nodeLatencies = await Promise.all(
      discoveredNodes.map(async (node) => {
        const startTime = Date.now();
        try {
          await fetch(`http://${node}/api/health`);
          return { node, latency: Date.now() - startTime };
        } catch (error) {
          return { node, latency: Infinity };
        }
      })
    );

    // Sort by latency and store
    this.edgeNodes = nodeLatencies
      .filter(n => n.latency < 100)
      .sort((a, b) => a.latency - b.latency);
    
    this.activeNode = this.edgeNodes[0]?.node;
    await AsyncStorage.setItem('activeEdgeNode', this.activeNode);
  }

  async sendQuery(prompt, options = {}) {
    if (!this.activeNode) {
      await this.discoverEdgeNodes();
    }

    const requestBody = {
      model: options.model || 'llama3.2-3b-q4',
      prompt: prompt,
      stream: false,
      options: {
        temperature: options.temperature || 0.7,
        max_tokens: options.max_tokens || 256
      }
    };

    try {
      const response = await this.makeRequest(requestBody);
      return response.response;
    } catch (error) {
      if (this.failoverEnabled && this.edgeNodes.length > 1) {
        return await this.handleFailover(requestBody);
      }
      throw error;
    }
  }

  async makeRequest(body, nodeIndex = 0) {
    const node = this.edgeNodes[nodeIndex]?.node || this.activeNode;
    
    const response = await fetch(`http://${node}:11434/api/generate`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(body),
      timeout: 5000 // 5 second timeout for edge requests
    });

    if (!response.ok) {
      throw new Error(`Edge node error: ${response.status}`);
    }

    return response.json();
  }

  async handleFailover(requestBody) {
    // Try next available edge node
    for (let i = 1; i < this.edgeNodes.length; i++) {
      try {
        const response = await this.makeRequest(requestBody, i);
        this.activeNode = this.edgeNodes[i].node;
        return response.response;
      } catch (error) {
        continue;
      }
    }
    throw new Error('All edge nodes unavailable');
  }
}

export default EdgeAIClient;

// ChatScreen.js - Mobile chat interface
import React, { useState, useEffect } from 'react';
import { View, Text, TextInput, TouchableOpacity, FlatList } from 'react-native';
import EdgeAIClient from './EdgeAIClient';

const ChatScreen = () => {
  const [messages, setMessages] = useState([]);
  const [inputText, setInputText] = useState('');
  const [isLoading, setIsLoading] = useState(false);
  const [edgeClient] = useState(new EdgeAIClient());
  const [latency, setLatency] = useState(0);

  useEffect(() => {
    // Initialize edge connection
    edgeClient.discoverEdgeNodes();
  }, []);

  const sendMessage = async () => {
    if (!inputText.trim()) return;

    const userMessage = { id: Date.now(), text: inputText, sender: 'user' };
    setMessages(prev => [...prev, userMessage]);
    setInputText('');
    setIsLoading(true);

    try {
      const startTime = Date.now();
      const response = await edgeClient.sendQuery(inputText);
      const responseTime = Date.now() - startTime;
      
      setLatency(responseTime);
      
      const aiMessage = {
        id: Date.now() + 1,
        text: response,
        sender: 'ai',
        latency: responseTime
      };
      
      setMessages(prev => [...prev, aiMessage]);
    } catch (error) {
      console.error('Edge AI error:', error);
      const errorMessage = {
        id: Date.now() + 1,
        text: 'Connection failed. Retrying...',
        sender: 'system'
      };
      setMessages(prev => [...prev, errorMessage]);
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <View style={{ flex: 1, padding: 20 }}>
      <Text style={{ fontSize: 16, marginBottom: 10 }}>
        Edge AI Chat (Latency: {latency}ms)
      </Text>
      
      <FlatList
        data={messages}
        keyExtractor={(item) => item.id.toString()}
        renderItem={({ item }) => (
          <View style={{
            padding: 10,
            marginVertical: 5,
            backgroundColor: item.sender === 'user' ? '#007AFF' : '#F0F0F0',
            borderRadius: 10,
            alignSelf: item.sender === 'user' ? 'flex-end' : 'flex-start'
          }}>
            <Text style={{
              color: item.sender === 'user' ? 'white' : 'black'
            }}>
              {item.text}
            </Text>
            {item.latency && (
              <Text style={{ fontSize: 12, color: '#666' }}>
                {item.latency}ms
              </Text>
            )}
          </View>
        )}
        style={{ flex: 1 }}
      />
      
      <View style={{ flexDirection: 'row', marginTop: 10 }}>
        <TextInput
          style={{
            flex: 1,
            borderWidth: 1,
            borderColor: '#ccc',
            padding: 10,
            borderRadius: 5
          }}
          value={inputText}
          onChangeText={setInputText}
          placeholder="Type your message..."
          editable={!isLoading}
        />
        <TouchableOpacity
          style={{
            backgroundColor: '#007AFF',
            padding: 10,
            borderRadius: 5,
            marginLeft: 10
          }}
          onPress={sendMessage}
          disabled={isLoading}
        >
          <Text style={{ color: 'white' }}>
            {isLoading ? 'Sending...' : 'Send'}
          </Text>
        </TouchableOpacity>
      </View>
    </View>
  );
};

export default ChatScreen;

# network-slice-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: ai-network-slice
data:
  slice-config: |
    slice_id: "ai-optimized-slice"
    latency_requirement: "50ms"
    bandwidth_guarantee: "100Mbps"
    priority: "high"
    qos_class: "real-time"
    
    traffic_rules:
      - match:
          protocol: "HTTP"
          port: 11434
        action:
          priority: 1
          guaranteed_bandwidth: "50Mbps"
      
      - match:
          app_type: "ai-inference"
        action:
          latency_target: "30ms"
          jitter_tolerance: "5ms"

# edge_load_balancer.py
import asyncio
import aiohttp
from datetime import datetime, timedelta

class EdgeLoadBalancer:
    def __init__(self):
        self.edge_nodes = []
        self.health_check_interval = 30  # seconds
        self.request_counts = {}
        
    async def register_edge_node(self, node_address, capacity=100):
        """Register an edge node with capacity"""
        node = {
            'address': node_address,
            'capacity': capacity,
            'current_load': 0,
            'last_health_check': datetime.now(),
            'healthy': True,
            'avg_response_time': 0
        }
        self.edge_nodes.append(node)
        self.request_counts[node_address] = 0
        
    async def health_check(self):
        """Check health of all edge nodes"""
        for node in self.edge_nodes:
            try:
                start_time = datetime.now()
                async with aiohttp.ClientSession() as session:
                    async with session.get(
                        f"http://{node['address']}:11434/api/health",
                        timeout=aiohttp.ClientTimeout(total=5)
                    ) as response:
                        if response.status == 200:
                            response_time = (datetime.now() - start_time).total_seconds() * 1000
                            node['avg_response_time'] = response_time
                            node['healthy'] = True
                        else:
                            node['healthy'] = False
            except Exception:
                node['healthy'] = False
            
            node['last_health_check'] = datetime.now()
    
    def select_best_node(self):
        """Select the best available edge node"""
        healthy_nodes = [n for n in self.edge_nodes if n['healthy']]
        
        if not healthy_nodes:
            return None
        
        # Calculate load score (lower is better)
        for node in healthy_nodes:
            load_ratio = node['current_load'] / node['capacity']
            latency_score = node['avg_response_time'] / 100  # normalize to 0-1
            node['score'] = load_ratio + latency_score
        
        # Return node with lowest score
        return min(healthy_nodes, key=lambda x: x['score'])
    
    async def forward_request(self, request_data):
        """Forward request to best available edge node"""
        best_node = self.select_best_node()
        
        if not best_node:
            raise Exception("No healthy edge nodes available")
        
        # Increment load
        best_node['current_load'] += 1
        
        try:
            async with aiohttp.ClientSession() as session:
                async with session.post(
                    f"http://{best_node['address']}:11434/api/generate",
                    json=request_data,
                    timeout=aiohttp.ClientTimeout(total=30)
                ) as response:
                    result = await response.json()
                    return result
        finally:
            # Decrement load
            best_node['current_load'] -= 1
            self.request_counts[best_node['address']] += 1

# Usage example
async def main():
    balancer = EdgeLoadBalancer()
    
    # Register edge nodes
    await balancer.register_edge_node("192.168.1.100", capacity=50)
    await balancer.register_edge_node("192.168.1.101", capacity=75)
    await balancer.register_edge_node("192.168.1.102", capacity=100)
    
    # Start health checking
    asyncio.create_task(periodic_health_check(balancer))
    
    # Handle incoming requests
    request_data = {
        "model": "llama3.2-3b-q4",
        "prompt": "Hello, how are you?",
        "stream": False
    }
    
    response = await balancer.forward_request(request_data)
    print(f"Response: {response}")

async def periodic_health_check(balancer):
    while True:
        await balancer.health_check()
        await asyncio.sleep(30)

if __name__ == "__main__":
    asyncio.run(main())

// edge-metrics.js
class EdgeMetrics {
  constructor() {
    this.metrics = {
      requests_per_second: 0,
      average_latency: 0,
      error_rate: 0,
      model_utilization: {},
      network_usage: 0
    };
    
    this.metricsHistory = [];
    this.collectors = [];
  }

  startMetricsCollection() {
    // Collect metrics every 10 seconds
    setInterval(() => {
      this.collectMetrics();
    }, 10000);
  }

  async collectMetrics() {
    const timestamp = Date.now();
    const currentMetrics = {
      timestamp,
      requests_per_second: this.calculateRPS(),
      average_latency: this.calculateAvgLatency(),
      error_rate: this.calculateErrorRate(),
      active_connections: this.getActiveConnections(),
      memory_usage: await this.getMemoryUsage(),
      cpu_usage: await this.getCPUUsage()
    };

    this.metricsHistory.push(currentMetrics);
    
    // Keep only last 24 hours of data
    const oneDayAgo = timestamp - (24 * 60 * 60 * 1000);
    this.metricsHistory = this.metricsHistory.filter(
      m => m.timestamp > oneDayAgo
    );

    // Send to monitoring system
    await this.sendToMonitoring(currentMetrics);
  }

  calculateRPS() {
    // Calculate requests per second from recent history
    const oneMinuteAgo = Date.now() - 60000;
    const recentRequests = this.metricsHistory.filter(
      m => m.timestamp > oneMinuteAgo
    );
    
    return recentRequests.length / 60;
  }

  calculateAvgLatency() {
    const recent = this.metricsHistory.slice(-10);
    if (recent.length === 0) return 0;
    
    const totalLatency = recent.reduce((sum, m) => sum + m.latency, 0);
    return totalLatency / recent.length;
  }

  async sendToMonitoring(metrics) {
    // Send metrics to monitoring service
    try {
      await fetch('/api/metrics', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(metrics)
      });
    } catch (error) {
      console.error('Failed to send metrics:', error);
    }
  }

  getPerformanceReport() {
    const report = {
      summary: {
        total_requests: this.metricsHistory.length,
        avg_latency: this.calculateAvgLatency(),
        uptime_percentage: this.calculateUptime(),
        peak_rps: Math.max(...this.metricsHistory.map(m => m.requests_per_second))
      },
      latency_distribution: this.calculateLatencyDistribution(),
      error_analysis: this.analyzeErrors(),
      recommendations: this.generateRecommendations()
    };

    return report;
  }

  calculateLatencyDistribution() {
    const latencies = this.metricsHistory.map(m => m.latency);
    latencies.sort((a, b) => a - b);
    
    return {
      p50: latencies[Math.floor(latencies.length * 0.5)],
      p90: latencies[Math.floor(latencies.length * 0.9)],
      p95: latencies[Math.floor(latencies.length * 0.95)],
      p99: latencies[Math.floor(latencies.length * 0.99)]
    };
  }

  generateRecommendations() {
    const recommendations = [];
    const avgLatency = this.calculateAvgLatency();
    
    if (avgLatency > 100) {
      recommendations.push({
        type: 'performance',
        message: 'Consider adding more edge nodes to reduce latency',
        priority: 'high'
      });
    }
    
    if (this.calculateErrorRate() > 0.05) {
      recommendations.push({
        type: 'reliability',
        message: 'High error rate detected, check edge node health',
        priority: 'critical'
      });
    }
    
    return recommendations;
  }
}

export default EdgeMetrics;

// cost-calculator.js
const costCalculator = {
  cloud: {
    compute: 850,      // Cloud GPU instances
    bandwidth: 1250,   // Data transfer costs
    storage: 150,      // Model storage
    total: 2250
  },
  
  edge: {
    hardware: 400,     // Edge node amortization
    bandwidth: 250,    // Reduced data transfer
    maintenance: 200,  // Support and updates
    total: 850
  },
  
  savings: function() {
    return this.cloud.total - this.edge.total;
  },
  
  roi_months: function() {
    const initial_investment = 5000; // Edge hardware
    const monthly_savings = this.savings();
    return Math.ceil(initial_investment / monthly_savings);
  }
};

console.log(`Monthly savings: $${costCalculator.savings()}`);
console.log(`ROI achieved in: ${costCalculator.roi_months()} months`);

# ollama-edge-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-edge
  labels:
    app: ollama-edge
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ollama-edge
  template:
    metadata:
      labels:
        app: ollama-edge
    spec:
      containers:
      - name: ollama
        image: ollama/ollama:latest
        ports:
        - containerPort: 11434
        env:
        - name: OLLAMA_HOST
          value: "0.0.0.0:11434"
        - name: OLLAMA_MAX_LOADED_MODELS
          value: "2"
        - name: OLLAMA_FLASH_ATTENTION
          value: "1"
        resources:
          requests:
            memory: "8Gi"
            cpu: "2"
          limits:
            memory: "16Gi"
            cpu: "4"
        volumeMounts:
        - name: model-storage
          mountPath: /root/.ollama
        readinessProbe:
          httpGet:
            path: /api/health
            port: 11434
          initialDelaySeconds: 30
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /api/health
            port: 11434
          initialDelaySeconds: 60
          periodSeconds: 30
      volumes:
      - name: model-storage
        persistentVolumeClaim:
          claimName: ollama-pvc
      nodeSelector:
        node-type: edge
        
---
apiVersion: v1
kind: Service
metadata:
  name: ollama-edge-service
spec:
  selector:
    app: ollama-edge
  ports:
  - port: 11434
    targetPort: 11434
    protocol: TCP
  type: LoadBalancer
  
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ollama-edge-ingress
  annotations:
    nginx.ingress.kubernetes.io/upstream-hash-by: "$remote_addr"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
spec:
  rules:
  - host: ollama-edge.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: ollama-edge-service
            port:
              number: 11434

# docker-compose.edge.yml
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama-edge
    ports:
      - "11434:11434"
    environment:
      - OLLAMA_HOST=0.0.0.0:11434
      - OLLAMA_MAX_LOADED_MODELS=2
      - OLLAMA_FLASH_ATTENTION=1
      - OLLAMA_NUM_PARALLEL=4
    volumes:
      - ollama_data:/root/.ollama
      - ./models:/models
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 16G
        reservations:
          memory: 8G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

  nginx:
    image: nginx:alpine
    container_name: ollama-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - ollama
    restart: unless-stopped

  metrics:
    image: prom/prometheus:latest
    container_name: ollama-metrics
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/etc/prometheus/console_libraries'
      - '--web.console.templates=/etc/prometheus/consoles'
    restart: unless-stopped

volumes:
  ollama_data:
  prometheus_data:

networks:
  default:
    driver: bridge

#!/bin/bash
# edge-security-setup.sh

# Configure firewall for edge nodes
sudo ufw enable
sudo ufw default deny incoming
sudo ufw default allow outgoing

# Allow Ollama API (restrict to known IPs)
sudo ufw allow from 192.168.1.0/24 to any port 11434

# Allow SSH (change default port)
sudo ufw allow 2222/tcp

# Enable fail2ban for SSH protection
sudo apt-get install fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban

# Configure TLS for Ollama API
sudo mkdir -p /etc/ollama/ssl
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /etc/ollama/ssl/ollama.key \
  -out /etc/ollama/ssl/ollama.crt \
  -subj "/C=US/ST=State/L=City/O=Organization/CN=ollama-edge"

# Set up API key authentication
echo "OLLAMA_API_KEY=$(openssl rand -hex 32)" >> /etc/environment

# model_security.py
import hashlib
import hmac
import time
from cryptography.fernet import Fernet

class SecureModelManager:
    def __init__(self, encryption_key=None):
        self.encryption_key = encryption_key or Fernet.generate_key()
        self.cipher = Fernet(self.encryption_key)
        self.authorized_keys = set()
        
    def encrypt_model(self, model_path, encrypted_path):
        """Encrypt model file for secure storage"""
        with open(model_path, 'rb') as f:
            model_data = f.read()
        
        encrypted_data = self.cipher.encrypt(model_data)
        
        with open(encrypted_path, 'wb') as f:
            f.write(encrypted_data)
        
        return encrypted_path
    
    def decrypt_model(self, encrypted_path, output_path):
        """Decrypt model file for use"""
        with open(encrypted_path, 'rb') as f:
            encrypted_data = f.read()
        
        decrypted_data = self.cipher.decrypt(encrypted_data)
        
        with open(output_path, 'wb') as f:
            f.write(decrypted_data)
        
        return output_path
    
    def validate_api_request(self, request_data, signature, api_key):
        """Validate API request with HMAC signature"""
        if api_key not in self.authorized_keys:
            return False
        
        message = f"{request_data}{int(time.time() // 300)}"  # 5-minute window
        expected_signature = hmac.new(
            api_key.encode(),
            message.encode(),
            hashlib.sha256
        ).hexdigest()
        
        return hmac.compare_digest(signature, expected_signature)
    
    def add_authorized_key(self, api_key):
        """Add authorized API key"""
        self.authorized_keys.add(api_key)
    
    def generate_model_checksum(self, model_path):
        """Generate checksum for model integrity verification"""
        sha256_hash = hashlib.sha256()
        with open(model_path, 'rb') as f:
            for chunk in iter(lambda: f.read(4096), b""):
                sha256_hash.update(chunk)
        return sha256_hash.hexdigest()

# Usage example
security_manager = SecureModelManager()
security_manager.add_authorized_key("your-api-key-here")

# Encrypt model for secure storage
security_manager.encrypt_model("/models/llama3.2-3b.bin", "/secure/encrypted_model.bin")

#!/bin/bash
# edge-diagnostics.sh

echo "=== Edge AI Diagnostics ==="

# Check Ollama service status
echo "1. Checking Ollama service..."
systemctl status ollama

# Test API connectivity
echo "2. Testing API connectivity..."
curl -X POST http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{"model": "llama3.2-3b", "prompt": "test", "stream": false}' \
  --connect-timeout 5 \
  --max-time 10

# Check network latency
echo "3. Network latency test..."
ping -c 5 8.8.8.8

# Check resource usage
echo "4. Resource usage..."
free -h
df -h
top -bn1 | head -20

# Check model availability
echo "5. Available models..."
ollama list

# Check logs for errors
echo "6. Recent errors..."
journalctl -u ollama --since "1 hour ago" | grep -i error

# performance_optimizer.py
import psutil
import subprocess
import json
from datetime import datetime

class EdgeOptimizer:
    def __init__(self):
        self.metrics = {}
        
    def analyze_performance(self):
        """Analyze current system performance"""
        metrics = {
            'cpu_usage': psutil.cpu_percent(interval=1),
            'memory_usage': psutil.virtual_memory().percent,
            'disk_usage': psutil.disk_usage('/').percent,
            'network_io': psutil.net_io_counters()._asdict(),
            'process_count': len(psutil.pids()),
            'load_average': psutil.getloadavg()
        }
        
        self.metrics = metrics
        return metrics
    
    def optimize_ollama_config(self):
        """Generate optimized Ollama configuration"""
        cpu_cores = psutil.cpu_count()
        memory_gb = psutil.virtual_memory().total // (1024**3)
        
        # Calculate optimal settings
        max_models = min(2, memory_gb // 8)  # 8GB per model
        num_parallel = min(4, cpu_cores // 2)
        
        config = {
            'OLLAMA_MAX_LOADED_MODELS': max_models,
            'OLLAMA_NUM_PARALLEL': num_parallel,
            'OLLAMA_FLASH_ATTENTION': 1,
            'OLLAMA_HOST': '0.0.0.0:11434'
        }
        
        return config
    
    def apply_system_optimizations(self):
        """Apply system-level optimizations"""
        optimizations = []
        
        # Increase file descriptor limits
        try:
            subprocess.run(['sudo', 'sysctl', '-w', 'fs.file-max=2097152'], check=True)
            optimizations.append("Increased file descriptor limit")
        except subprocess.CalledProcessError:
            pass
        
        # Optimize network settings
        try:
            subprocess.run(['sudo', 'sysctl', '-w', 'net.core.rmem_max=16777216'], check=True)
            subprocess.run(['sudo', 'sysctl', '-w', 'net.core.wmem_max=16777216'], check=True)
            optimizations.append("Optimized network buffers")
        except subprocess.CalledProcessError:
            pass
        
        # Set CPU governor to performance
        try:
            subprocess.run(['sudo', 'cpupower', 'frequency-set', '-g', 'performance'], check=True)
            optimizations.append("Set CPU governor to performance")
        except subprocess.CalledProcessError:
            pass
        
        return optimizations
    
    def generate_optimization_report(self):
        """Generate comprehensive optimization report"""
        metrics = self.analyze_performance()
        recommendations = []
        
        if metrics['cpu_usage'] > 80:
            recommendations.append({
                'issue': 'High CPU usage',
                'solution': 'Reduce OLLAMA_NUM_PARALLEL or upgrade CPU',
                'priority': 'high'
            })
        
        if metrics['memory_usage'] > 90:
            recommendations.append({
                'issue': 'High memory usage',
                'solution': 'Reduce OLLAMA_MAX_LOADED_MODELS or add RAM',
                'priority': 'critical'
            })
        
        if metrics['disk_usage'] > 85:
            recommendations.append({
                'issue': 'High disk usage',
                'solution': 'Clean up old models or expand storage',
                'priority': 'medium'
            })
        
        return {
            'timestamp': datetime.now().isoformat(),
            'metrics': metrics,
            'recommendations': recommendations,
            'optimal_config': self.optimize_ollama_config()
        }

# Usage
optimizer = EdgeOptimizer()
report = optimizer.generate_optimization_report()
print(json.dumps(report, indent=2))

# model_cache.py
import time
import threading
from collections import defaultdict, OrderedDict

class IntelligentModelCache:
    def __init__(self, max_cache_size=3, ttl=3600):
        self.max_cache_size = max_cache_size
        self.ttl = ttl
        self.cache = OrderedDict()
        self.access_count = defaultdict(int)
        self.last_access = {}
        self.lock = threading.Lock()
        
    def get_model_priority(self, model_name):
        """Calculate model priority based on usage patterns"""
        current_time = time.time()
        
        # Factors: access frequency, recency, model size
        access_freq = self.access_count[model_name]
        last_used = self.last_access.get(model_name, 0)
        recency_score = max(0, 1 - (current_time - last_used) / self.ttl)
        
        # Simple scoring algorithm
        priority = access_freq * 0.6 + recency_score * 0.4
        return priority
    
    def should_cache_model(self, model_name):
        """Determine if model should be cached"""
        if len(self.cache) < self.max_cache_size:
            return True
        
        # Calculate priorities for all models
        priorities = {}
        for cached_model in self.cache.keys():
            priorities[cached_model] = self.get_model_priority(cached_model)
        
        new_model_priority = self.get_model_priority(model_name)
        min_priority = min(priorities.values())
        
        return new_model_priority > min_priority
    
    def evict_least_priority_model(self):
        """Remove the least priority model from cache"""
        if not self.cache:
            return None
        
        priorities = {}
        for model_name in self.cache.keys():
            priorities[model_name] = self.get_model_priority(model_name)
        
        # Find model with lowest priority
        least_priority_model = min(priorities.keys(), key=lambda x: priorities[x])
        return self.cache.pop(least_priority_model)
    
    def cache_model(self, model_name, model_data):
        """Cache a model with intelligent eviction"""
        with self.lock:
            current_time = time.time()
            
            # Update access statistics
            self.access_count[model_name] += 1
            self.last_access[model_name] = current_time
            
            # Check if we need to evict
            if len(self.cache) >= self.max_cache_size:
                if self.should_cache_model(model_name):
                    evicted = self.evict_least_priority_model()
                    if evicted:
                        print(f"Evicted model: {list(evicted.keys())[0] if evicted else 'None'}")
                else:
                    return False
            
            # Cache the model
            self.cache[model_name] = {
                'data': model_data,
                'cached_at': current_time,
                'access_count': self.access_count[model_name]
            }
            
            return True
    
    def get_model(self, model_name):
        """Retrieve model from cache"""
        with self.lock:
            if model_name in self.cache:
                # Update access statistics
                self.access_count[model_name] += 1
                self.last_access[model_name] = time.time()
                
                # Move to end (most recently used)
                self.cache.move_to_end(model_name)
                
                return self.cache[model_name]['data']
            
            return None
    
    def cleanup_expired(self):
        """Remove expired models from cache"""
        current_time = time.time()
        expired_models = []
        
        for model_name, model_info in self.cache.items():
            if current_time - model_info['cached_at'] > self.ttl:
                expired_models.append(model_name)
        
        for model_name in expired_models:
            del self.cache[model_name]
        
        return len(expired_models)
    
    def get_cache_stats(self):
        """Get cache statistics"""
        return {
            'cache_size': len(self.cache),
            'max_size': self.max_cache_size,
            'hit_rate': self.calculate_hit_rate(),
            'most_accessed': max(self.access_count.items(), key=lambda x: x[1]) if self.access_count else None,
            'cache_utilization': len(self.cache) / self.max_cache_size
        }
    
    def calculate_hit_rate(self):
        """Calculate cache hit rate"""
        total_accesses = sum(self.access_count.values())
        if total_accesses == 0:
            return 0.0
        
        cache_hits = sum(count for model, count in self.access_count.items() if model in self.cache)
        return cache_hits / total_accesses

# Usage example
cache = IntelligentModelCache(max_cache_size=3, ttl=3600)

# Simulate model usage
models = ['llama3.2-3b', 'phi3-mini', 'gemma2-2b', 'mistral-7b']
for i in range(100):
    model = models[i % len(models)]
    
    # Try to get from cache
    cached_model = cache.get_model(model)
    if cached_model is None:
        # Simulate loading model
        model_data = f"Model data for {model}"
        cache.cache_model(model, model_data)
        print(f"Loaded and cached: {model}")
    else:
        print(f"Cache hit: {model}")

# Print cache statistics
stats = cache.get_cache_stats()
print(f"\nCache Statistics: {stats}")

# federated_learning.py
import asyncio
import json
import numpy as np
from datetime import datetime

class FederatedLearningCoordinator:
    def __init__(self, edge_nodes):
        self.edge_nodes = edge_nodes
        self.global_model = None
        self.round_number = 0
        self.client_updates = {}
        self.learning_rate = 0.01
        
    async def start_federated_round(self, model_config):
        """Start a new federated learning round"""
        self.round_number += 1
        self.client_updates = {}
        
        print(f"Starting federated round {self.round_number}")
        
        # Send global model to all edge nodes
        tasks = []
        for node in self.edge_nodes:
            task = self.send_model_to_node(node, model_config)
            tasks.append(task)
        
        # Wait for all nodes to receive the model
        await asyncio.gather(*tasks)
        
        # Collect local updates
        update_tasks = []
        for node in self.edge_nodes:
            task = self.collect_local_update(node)
            update_tasks.append(task)
        
        # Wait for all updates
        updates = await asyncio.gather(*update_tasks)
        
        # Aggregate updates
        aggregated_model = self.aggregate_updates(updates)
        
        # Update global model
        self.global_model = aggregated_model
        
        return aggregated_model
    
    async def send_model_to_node(self, node, model_config):
        """Send current global model to edge node"""
        try:
            # Simulate sending model to edge node
            await asyncio.sleep(0.1)  # Network delay
            
            payload = {
                'model_config': model_config,
                'global_model': self.global_model,
                'round_number': self.round_number
            }
            
            print(f"Sent model to node {node['id']}")
            return True
            
        except Exception as e:
            print(f"Failed to send model to node {node['id']}: {e}")
            return False
    
    async def collect_local_update(self, node):
        """Collect local model update from edge node"""
        try:
            # Simulate local training and update collection
            await asyncio.sleep(2.0)  # Training time
            
            # Simulate model update (in real implementation, this would be actual gradients)
            local_update = {
                'node_id': node['id'],
                'update': np.random.randn(100),  # Simulated model parameters
                'data_samples': np.random.randint(10, 100),
                'training_loss': np.random.uniform(0.1, 0.5),
                'timestamp': datetime.now().isoformat()
            }
            
            self.client_updates[node['id']] = local_update
            print(f"Collected update from node {node['id']}")
            
            return local_update
            
        except Exception as e:
            print(f"Failed to collect update from node {node['id']}: {e}")
            return None
    
    def aggregate_updates(self, updates):
        """Aggregate updates from all edge nodes using FedAvg"""
        if not updates or all(u is None for u in updates):
            return self.global_model
        
        # Filter out None updates
        valid_updates = [u for u in updates if u is not None]
        
        if not valid_updates:
            return self.global_model
        
        # Calculate weighted average based on number of data samples
        total_samples = sum(update['data_samples'] for update in valid_updates)
        
        if total_samples == 0:
            return self.global_model
        
        # Weighted aggregation
        aggregated_update = np.zeros_like(valid_updates[0]['update'])
        
        for update in valid_updates:
            weight = update['data_samples'] / total_samples
            aggregated_update += weight * update['update']
        
        # Apply aggregated update to global model
        if self.global_model is None:
            self.global_model = aggregated_update
        else:
            self.global_model = self.global_model + self.learning_rate * aggregated_update
        
        # Log aggregation results
        avg_loss = np.mean([u['training_loss'] for u in valid_updates])
        print(f"Aggregated {len(valid_updates)} updates, avg loss: {avg_loss:.4f}")
        
        return self.global_model
    
    def get_federation_stats(self):
        """Get federated learning statistics"""
        if not self.client_updates:
            return {}
        
        total_samples = sum(update['data_samples'] for update in self.client_updates.values())
        avg_loss = np.mean([update['training_loss'] for update in self.client_updates.values()])
        
        return {
            'round_number': self.round_number,
            'participating_nodes': len(self.client_updates),
            'total_data_samples': total_samples,
            'average_loss': avg_loss,
            'model_size': len(self.global_model) if self.global_model is not None else 0
        }

# Usage example
async def run_federated_learning():
    # Define edge nodes
    edge_nodes = [
        {'id': 'edge-01', 'location': 'New York'},
        {'id': 'edge-02', 'location': 'Los Angeles'},
        {'id': 'edge-03', 'location': 'Chicago'}
    ]
    
    # Initialize coordinator
    coordinator = FederatedLearningCoordinator(edge_nodes)
    
    # Run multiple federated rounds
    for round_num in range(5):
        model_config = {
            'model_type': 'llama3.2-3b',
            'learning_rate': 0.01,
            'batch_size': 32
        }
        
        await coordinator.start_federated_round(model_config)
        
        # Print round statistics
        stats = coordinator.get_federation_stats()
        print(f"Round {round_num + 1} Stats: {stats}")
        
        # Wait before next round
        await asyncio.sleep(1)

# Run the federated learning simulation
if __name__ == "__main__":
    asyncio.run(run_federated_learning())