Bazzite-AI Environment Setup¶

import torch
import gc

print("=" * 50)
print("GPU & Environment Status")
print("=" * 50)

# Check PyTorch CUDA availability
print(f"\nPyTorch version: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")

if torch.cuda.is_available():
    print(f"CUDA version: {torch.version.cuda}")
    print(f"GPU count: {torch.cuda.device_count()}")
    print(f"Current device: {torch.cuda.current_device()}")
    print(f"GPU name: {torch.cuda.get_device_name(0)}")

# System-wide GPU memory check using pynvml
try:
    import pynvml
    pynvml.nvmlInit()
    device_count = pynvml.nvmlDeviceGetCount()
    
    print(f"\n--- System-Wide GPU Memory ---")
    
    for i in range(device_count):
        handle = pynvml.nvmlDeviceGetHandleByIndex(i)
        name = pynvml.nvmlDeviceGetName(handle)
        info = pynvml.nvmlDeviceGetMemoryInfo(handle)
        
        total_gb = info.total / 1024**3
        used_gb = info.used / 1024**3
        free_gb = info.free / 1024**3
        usage_pct = (info.used / info.total) * 100
        
        print(f"\nGPU {i}: {name}")
        print(f"  Total:  {total_gb:.2f} GB")
        print(f"  Used:   {used_gb:.2f} GB ({usage_pct:.1f}%)")
        print(f"  Free:   {free_gb:.2f} GB")
        
        # Warning thresholds
        if free_gb < 4.0:
            print(f"  \u26a0\ufe0f  CRITICAL: Very low GPU memory!")
            print(f"      Shutdown other notebook kernels before proceeding.")
        elif free_gb < 6.0:
            print(f"  \u26a0\ufe0f  WARNING: Low GPU memory.")
            print(f"      7B models need ~5GB with 4-bit quantization.")
    
    pynvml.nvmlShutdown()
    
except ImportError:
    print("\n\u26a0\ufe0f  pynvml not installed - using PyTorch memory info (per-process only)")
    if torch.cuda.is_available():
        for i in range(torch.cuda.device_count()):
            total = torch.cuda.get_device_properties(i).total_memory / 1024**3
            allocated = torch.cuda.memory_allocated(i) / 1024**3
            print(f"  GPU {i}: {allocated:.2f} / {total:.2f} GB (this process only)")

# Quick GPU test
if torch.cuda.is_available():
    print("\n--- GPU Computation Test ---")
    try:
        x = torch.randn(1000, 1000, device="cuda")
        y = torch.matmul(x, x)
        del x, y
        torch.cuda.empty_cache()
        print("\u2705 GPU computation test passed!")
    except Exception as e:
        print(f"\u274c GPU test failed: {e}")
else:
    print("\n\u26a0\ufe0f  No GPU available - running on CPU only")

print("\n" + "=" * 50)

import os
import requests

# Ollama configuration
OLLAMA_HOST = os.getenv("OLLAMA_HOST", "http://ollama:11434")

print(f"Ollama host: {OLLAMA_HOST}")
print("\n--- Checking Ollama Connection ---")

def check_ollama_health():
    """Check if Ollama server is running and healthy."""
    try:
        response = requests.get(f"{OLLAMA_HOST}/api/tags", timeout=5)
        if response.status_code == 200:
            return True, response.json()
        return False, f"Unexpected status: {response.status_code}"
    except requests.exceptions.ConnectionError:
        return False, "Connection refused - Ollama pod not running"
    except requests.exceptions.Timeout:
        return False, "Connection timed out"
    except Exception as e:
        return False, str(e)

is_running, result = check_ollama_health()

if is_running:
    print("\u2705 Ollama server is running!")
    models = result.get("models", [])
    if models:
        print(f"\nAvailable models ({len(models)}):")
        for m in models:
            name = m.get("name", "Unknown")
            size_gb = m.get("size", 0) / 1024**3
            print(f"  - {name} ({size_gb:.1f} GB)")
    else:
        print("\nNo models pulled yet (we'll pull them in the next step).")
else:
    print(f"\u274c Ollama is not running: {result}")
    print("\n--- How to Start Ollama ---")
    print("Run this command in a terminal:")
    print("")
    print("    ujust ollama start")
    print("")
    print("Then re-run this cell to verify the connection.")

import json

# Required models for the course
REQUIRED_MODELS = [
    {
        "name": "hf.co/NousResearch/Nous-Hermes-2-Mistral-7B-DPO-GGUF:Q4_K_M",
        "used_by": "D1 notebooks (Prompt Engineering)",
        "size_hint": "~4.4 GB"
    },
    {
        "name": "llama3.2:latest",
        "used_by": "D2 notebooks (RAG)",
        "size_hint": "~2.0 GB"
    }
]

def get_available_models():
    """Get list of models available in Ollama."""
    try:
        response = requests.get(f"{OLLAMA_HOST}/api/tags", timeout=5)
        if response.status_code == 200:
            return [m.get("name", "") for m in response.json().get("models", [])]
    except:
        pass
    return []

def pull_model(model_name):
    """Pull a model from Ollama, showing progress."""
    print(f"\nPulling '{model_name}'...")
    print("(This may take several minutes for large models)")
    
    try:
        response = requests.post(
            f"{OLLAMA_HOST}/api/pull",
            json={"name": model_name},
            stream=True,
            timeout=1800  # 30 minute timeout for large models
        )
        
        last_status = ""
        for line in response.iter_lines():
            if line:
                data = json.loads(line)
                status = data.get("status", "")
                
                # Show download progress
                if "pulling" in status or "downloading" in status:
                    completed = data.get("completed", 0)
                    total = data.get("total", 0)
                    if total > 0:
                        pct = (completed / total) * 100
                        print(f"\r  Progress: {pct:.1f}%", end="", flush=True)
                elif status != last_status:
                    if last_status:
                        print()  # newline after progress
                    print(f"  {status}")
                    last_status = status
                
                if status == "success":
                    print(f"\n\u2705 Model '{model_name}' pulled successfully!")
                    return True
        
        return True
    except Exception as e:
        print(f"\n\u274c Failed to pull model: {e}")
        return False

# Check connection first
is_running, _ = check_ollama_health()
if not is_running:
    print("\u274c Ollama is not running. Start it first with: ujust ollama start")
else:
    print("Checking required models...\n")
    available = get_available_models()
    
    all_ready = True
    for model_info in REQUIRED_MODELS:
        model_name = model_info["name"]
        
        # Check if model is available (exact match or prefix match)
        is_available = any(model_name in m or m in model_name for m in available)
        
        if is_available:
            print(f"\u2705 {model_name}")
            print(f"   Used by: {model_info['used_by']}")
        else:
            print(f"\u274c {model_name} - NOT FOUND")
            print(f"   Used by: {model_info['used_by']}")
            print(f"   Size: {model_info['size_hint']}")
            
            # Auto-pull missing model
            success = pull_model(model_name)
            if not success:
                all_ready = False
    
    print("\n" + "=" * 50)
    if all_ready:
        print("\u2705 All required models are available!")
    else:
        print("\u26a0\ufe0f  Some models failed to download. Try manually:")
        print("    ujust ollama pull <model-name>")

# Quick API test
from openai import OpenAI

# === Model Configuration ===
HF_LLM_MODEL = "NousResearch/Nous-Hermes-2-Mistral-7B-DPO-GGUF"
OLLAMA_LLM_MODEL = f"hf.co/{HF_LLM_MODEL}:Q4_K_M"

print("Testing OpenAI-compatible API...")
print(f"Model: {OLLAMA_LLM_MODEL}")

try:
    client = OpenAI(
        base_url=f"{OLLAMA_HOST}/v1",
        api_key="ollama"
    )
    
    response = client.chat.completions.create(
        model=OLLAMA_LLM_MODEL,
        messages=[{"role": "user", "content": "Say 'Hello from Ollama!' in exactly 5 words."}],
        max_tokens=20
    )
    
    print(f"\u2705 API test passed!")
    print(f"\nResponse: {response.choices[0].message.content}")
    
except Exception as e:
    print(f"\u274c API test failed: {e}")
    print("\nMake sure Ollama is running and the model is pulled.")

from pathlib import Path

# With kernel cwd fix, notebooks run in their own directory
# Datasets are in ./datasets/ relative to this notebook
DATASETS_DIR = Path("./datasets")

print(f"Datasets directory: {DATASETS_DIR.resolve()}")
datasets = list(DATASETS_DIR.glob('*.csv'))
if datasets:
    print(f"Available datasets: {[d.name for d in datasets]}")

print("=" * 60)
print("ENVIRONMENT READINESS CHECK")
print("=" * 60)

checks = []

# 1. GPU Check
gpu_ok = torch.cuda.is_available()
checks.append(("GPU Access", gpu_ok, "CUDA available" if gpu_ok else "No GPU - CPU only"))

# 2. Ollama Check
ollama_ok, _ = check_ollama_health()
checks.append(("Ollama Server", ollama_ok, "Running" if ollama_ok else "Not running"))

# 3. Models Check
if ollama_ok:
    available = get_available_models()
    model_count = len(available)
    models_ok = model_count > 0
    checks.append(("Ollama Models", models_ok, f"{model_count} models available" if models_ok else "No models"))
else:
    checks.append(("Ollama Models", False, "Ollama not running"))

# 4. API Test
if ollama_ok and models_ok:
    try:
        client = OpenAI(base_url=f"{OLLAMA_HOST}/v1", api_key="ollama")
        # Quick test with small output
        response = client.chat.completions.create(
            model=available[0],
            messages=[{"role": "user", "content": "Hi"}],
            max_tokens=5
        )
        api_ok = True
    except:
        api_ok = False
    checks.append(("API Inference", api_ok, "Working" if api_ok else "Failed"))
else:
    checks.append(("API Inference", False, "Prerequisites not met"))

# Print results
print("\n")
all_ok = True
for name, ok, detail in checks:
    status = "\u2705" if ok else "\u274c"
    print(f"{status} {name}: {detail}")
    if not ok and name not in ["GPU Access"]:  # GPU is optional
        all_ok = False

print("\n" + "=" * 60)
if all_ok:
    print("\u2705 ENVIRONMENT READY!")
    print("\nYou can now proceed to D1_01_Prompting_with_LangChain.ipynb")
else:
    print("\u26a0\ufe0f  SOME ISSUES DETECTED")
    print("\nPlease resolve the issues above before continuing.")
    if not ollama_ok:
        print("\nTo start Ollama, run in a terminal:")
        print("    ujust ollama start")
print("=" * 60)