Migration OpenAI vers Ollama : Cas Réel €4200→€109/mois

# Script d'évaluation comparative (eval_models.py) import ollama from openai import OpenAI import time import json # Dataset test : 100 exemples réels anonymisés test_cases = json.load(open("test_dataset.json")) def evaluate_model(model_name, api_type="ollama"): """Évalue un modèle sur qualité, latence, coût.""" results = { "model": model_name, "quality_scores": [], "latencies": [], "errors": 0 } for i, test in enumerate(test_cases[:100]): start = time.time() try: if api_type == "ollama": response = ollama.chat( model=model_name, messages=[ {"role": "system", "content": test["system_prompt"]}, {"role": "user", "content": test["user_prompt"]} ] ) output = response['message']['content'] cost = 0 # Ollama = gratuit elif api_type == "openai": client = OpenAI(api_key="sk-...") response = client.chat.completions.create( model=model_name, messages=[ {"role": "system", "content": test["system_prompt"]}, {"role": "user", "content": test["user_prompt"]} ] ) output = response.choices[0].message.content cost = response.usage.total_tokens * 0.00006 # GPT-4 Turbo latency = time.time() - start # Évaluation qualité (scoring humain de référence) quality_score = calculate_quality(output, test["reference_output"]) results["quality_scores"].append(quality_score) results["latencies"].append(latency) except Exception as e: results["errors"] += 1 print(f"Error on test {i}: {e}") # Métriques agrégées avg_quality = sum(results["quality_scores"]) / len(results["quality_scores"]) p50_latency = sorted(results["latencies"])[len(results["latencies"]) // 2] p95_latency = sorted(results["latencies"])[int(len(results["latencies"]) * 0.95)] return { "model": model_name, "avg_quality": f"{avg_quality:.1%}", "p50_latency": f"{p50_latency:.2f}s", "p95_latency": f"{p95_latency:.2f}s", "error_rate": f"{results['errors']}%" } # Évaluation sur 5 modèles models_to_test = [ ("gpt-4-turbo", "openai"), ("llama3.3:70b", "ollama"), ("llama3.3:8b", "ollama"), ("mistral:7b", "ollama"), ("qwen2.5:72b", "ollama") ] print("🔬 Évaluation comparative des modèles...") for model, api in models_to_test: result = evaluate_model(model, api) print(f"{model}: {result}") # Résultats réels obtenus : # gpt-4-turbo: {'avg_quality': '92.0%', 'p50_latency': '3.2s', 'p95_latency': '5.8s', 'error_rate': '0%'} # llama3.3:70b: {'avg_quality': '89.0%', 'p50_latency': '1.8s', 'p95_latency': '3.1s', 'error_rate': '1%'} # llama3.3:8b: {'avg_quality': '78.0%', 'p50_latency': '0.6s', 'p95_latency': '1.2s', 'error_rate': '3%'} # mistral:7b: {'avg_quality': '74.0%', 'p50_latency': '0.7s', 'p95_latency': '1.4s', 'error_rate': '2%'} # qwen2.5:72b: {'avg_quality': '87.0%', 'p50_latency': '2.1s', 'p95_latency': '3.6s', 'error_rate': '1%'}

# docker-compose.production.yml version: '3.8' services: # Ollama : serveur de modèles avec GPU ollama: image: ollama/ollama:latest container_name: ollama-prod volumes: - ollama_models:/root/.ollama - ./ollama-logs:/var/log/ollama ports: - "11434:11434" environment: - OLLAMA_HOST=0.0.0.0 - OLLAMA_KEEP_ALIVE=24h # Garde modèle en VRAM - OLLAMA_NUM_PARALLEL=4 # Max 4 requêtes concurrentes - OLLAMA_MAX_LOADED_MODELS=2 deploy: resources: reservations: devices: - driver: nvidia count: all capabilities: [gpu] healthcheck: test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"] interval: 30s timeout: 10s retries: 3 start_period: 60s restart: unless-stopped logging: driver: "json-file" options: max-size: "10m" max-file: "3" # NGINX : reverse proxy + load balancing nginx: image: nginx:alpine container_name: nginx-proxy ports: - "80:80" - "443:443" volumes: - ./nginx.conf:/etc/nginx/nginx.conf:ro - ./ssl:/etc/nginx/ssl:ro - nginx_logs:/var/log/nginx depends_on: ollama: condition: service_healthy restart: unless-stopped # Prometheus : monitoring métriques prometheus: image: prom/prometheus:latest container_name: prometheus 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' - '--storage.tsdb.retention.time=30d' restart: unless-stopped # Grafana : dashboards grafana: image: grafana/grafana:latest container_name: grafana ports: - "3000:3000" environment: - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD} - GF_INSTALL_PLUGINS=grafana-piechart-panel volumes: - grafana_data:/var/lib/grafana - ./grafana/dashboards:/etc/grafana/provisioning/dashboards:ro - ./grafana/datasources:/etc/grafana/provisioning/datasources:ro depends_on: - prometheus restart: unless-stopped # Node Exporter : métriques système node-exporter: image: prom/node-exporter:latest container_name: node-exporter ports: - "9100:9100" command: - '--path.rootfs=/host' volumes: - '/:/host:ro,rslave' restart: unless-stopped # NVIDIA DCGM Exporter : métriques GPU dcgm-exporter: image: nvcr.io/nvidia/k8s/dcgm-exporter:3.1.3-3.1.4-ubuntu20.04 container_name: dcgm-exporter ports: - "9400:9400" deploy: resources: reservations: devices: - driver: nvidia count: all capabilities: [gpu] restart: unless-stopped volumes: ollama_models: prometheus_data: grafana_data: nginx_logs: ollama_logs:

# nginx.conf : configuration reverse proxy events { worker_connections 2048; } http { upstream ollama_backend { least_conn; # Load balancing intelligent server ollama:11434 max_fails=3 fail_timeout=30s; keepalive 32; } # Rate limiting : 100 req/min par IP limit_req_zone $binary_remote_addr zone=api_limit:10m rate=100r/m; server { listen 80; server_name api.techdocs.example.com; # Redirect HTTP → HTTPS return 301 https://$server_name$request_uri; } server { listen 443 ssl http2; server_name api.techdocs.example.com; ssl_certificate /etc/nginx/ssl/fullchain.pem; ssl_certificate_key /etc/nginx/ssl/privkey.pem; ssl_protocols TLSv1.2 TLSv1.3; ssl_ciphers HIGH:!aNULL:!MD5; # Logs access_log /var/log/nginx/ollama-access.log; error_log /var/log/nginx/ollama-error.log; location /v1/chat/completions { limit_req zone=api_limit burst=20 nodelay; proxy_pass http://ollama_backend; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; # Timeouts élevés pour LLM proxy_connect_timeout 90s; proxy_send_timeout 180s; proxy_read_timeout 180s; # Streaming support proxy_buffering off; proxy_cache off; proxy_http_version 1.1; proxy_set_header Connection ""; # CORS add_header 'Access-Control-Allow-Origin' '*' always; add_header 'Access-Control-Allow-Methods' 'POST, OPTIONS' always; add_header 'Access-Control-Allow-Headers' 'Content-Type, Authorization' always; if ($request_method = 'OPTIONS') { return 204; } } location /health { access_log off; return 200 "OK\n"; add_header Content-Type text/plain; } } }

#!/bin/bash # deploy-ollama.sh : script de déploiement complet set -e # Exit on error echo "🚀 Déploiement Ollama Production..." # 1. Vérifier prérequis echo "✓ Vérification GPU..." nvidia-smi > /dev/null || { echo "❌ GPU NVIDIA non détecté"; exit 1; } echo "✓ Vérification Docker..." docker --version > /dev/null || { echo "❌ Docker non installé"; exit 1; } echo "✓ Vérification nvidia-docker..." docker run --rm --gpus all nvidia/cuda:12.0-base nvidia-smi > /dev/null || { echo "❌ nvidia-docker non configuré"; exit 1; } # 2. Créer répertoires mkdir -p ssl grafana/dashboards grafana/datasources ollama-logs # 3. Générer certificats SSL (Let's Encrypt) if [ ! -f "ssl/fullchain.pem" ]; then echo "📜 Génération certificats SSL..." docker run --rm -v $(pwd)/ssl:/etc/letsencrypt certbot/certbot certonly --standalone -d api.techdocs.example.com --agree-tos -m admin@techdocs.example.com cp /etc/letsencrypt/live/api.techdocs.example.com/fullchain.pem ssl/ cp /etc/letsencrypt/live/api.techdocs.example.com/privkey.pem ssl/ fi # 4. Démarrer services echo "🐳 Démarrage containers..." docker-compose -f docker-compose.production.yml up -d # 5. Attendre Ollama ready echo "⏳ Attente Ollama (60s)..." sleep 60 # 6. Télécharger modèle Llama 3.3 70B Q8 echo "📥 Téléchargement Llama 3.3 70B Q8 (~70GB, peut prendre 30-60min)..." docker exec ollama-prod ollama pull llama3.3:70b-q8_0 # 7. Preload modèle en VRAM (évite cold start) echo "🔥 Preload modèle en VRAM..." docker exec ollama-prod ollama run llama3.3:70b-q8_0 "Test" > /dev/null # 8. Vérifier santé echo "🏥 Healthcheck..." curl -f http://localhost:11434/api/tags || { echo "❌ Ollama non accessible"; exit 1; } # 9. Configurer monitoring echo "📊 Configuration Grafana..." # Import dashboard GPU (ID 12239) curl -X POST http://admin:${GRAFANA_PASSWORD}@localhost:3000/api/dashboards/import -H "Content-Type: application/json" -d '{"dashboard": {"id": 12239}, "overwrite": true, "inputs": [{"name": "DS_PROMETHEUS", "type": "datasource", "pluginId": "prometheus", "value": "Prometheus"}]}' echo "✅ Déploiement terminé !" echo "📍 Ollama API : https://api.techdocs.example.com/v1/chat/completions" echo "📍 Grafana : http://localhost:3000 (admin / ${GRAFANA_PASSWORD})" echo "📍 Prometheus : http://localhost:9090" # 10. Afficher métriques GPU echo "" echo "📊 État GPU actuel :" nvidia-smi --query-gpu=index,name,memory.used,memory.total,utilization.gpu,temperature.gpu --format=csv

# llm_client.py : abstraction LLM avec fallback OpenAI import os import time import logging from typing import Optional, Dict, List from enum import Enum import ollama from openai import OpenAI logger = logging.getLogger(__name__) class LLMProvider(Enum): OLLAMA = "ollama" OPENAI = "openai" class LLMClient: """ Client LLM unifié avec fallback automatique. Stratégie : 1. Essaye Ollama d'abord (coût = 0) 2. Si erreur ou qualité < seuil : fallback OpenAI 3. Track métriques (coût, latence, provider utilisé) """ def __init__( self, ollama_model: str = "llama3.3:70b-q8_0", ollama_base_url: str = "https://api.techdocs.example.com", openai_model: str = "gpt-4-turbo", openai_api_key: Optional[str] = None, enable_fallback: bool = True, confidence_threshold: float = 0.75 ): self.ollama_model = ollama_model self.openai_model = openai_model self.enable_fallback = enable_fallback self.confidence_threshold = confidence_threshold # Clients self.ollama_client = ollama.Client(host=ollama_base_url) self.openai_client = OpenAI(api_key=openai_api_key or os.getenv("OPENAI_API_KEY")) # Métriques self.stats = { "ollama_success": 0, "ollama_fallback": 0, "openai_only": 0, "total_cost": 0.0, "total_latency": 0.0, "total_requests": 0 } def chat( self, messages: List[Dict[str, str]], temperature: float = 0.7, max_tokens: int = 2000, force_provider: Optional[LLMProvider] = None ) -> Dict: """ Génère completion avec stratégie fallback. Returns: { 'content': str, 'provider': 'ollama' | 'openai', 'latency': float, 'cost': float, 'confidence': float } """ self.stats["total_requests"] += 1 start = time.time() # Force provider si spécifié if force_provider == LLMProvider.OPENAI: return self._call_openai(messages, temperature, max_tokens, start) # Tentative 1 : Ollama try: response = self._call_ollama(messages, temperature, max_tokens, start) # Vérifier confiance if response['confidence'] >= self.confidence_threshold: self.stats["ollama_success"] += 1 logger.info(f"✅ Ollama success (confidence: {response['confidence']:.2f})") return response # Confiance faible : fallback si activé if not self.enable_fallback: logger.warning(f"⚠️ Low confidence {response['confidence']:.2f} but fallback disabled") return response logger.warning(f"⚠️ Ollama confidence {response['confidence']:.2f} < {self.confidence_threshold}, fallback OpenAI") self.stats["ollama_fallback"] += 1 except Exception as e: logger.error(f"❌ Ollama error: {e}") if not self.enable_fallback: raise self.stats["ollama_fallback"] += 1 # Tentative 2 : OpenAI return self._call_openai(messages, temperature, max_tokens, start) def _call_ollama(self, messages, temperature, max_tokens, start) -> Dict: """Appel Ollama.""" response = self.ollama_client.chat( model=self.ollama_model, messages=messages, options={ "temperature": temperature, "num_predict": max_tokens } ) content = response['message']['content'] latency = time.time() - start # Estimer confiance (heuristique simple) confidence = self._estimate_confidence(content, messages) self.stats["total_latency"] += latency return { 'content': content, 'provider': 'ollama', 'latency': latency, 'cost': 0.0, 'confidence': confidence, 'model': self.ollama_model } def _call_openai(self, messages, temperature, max_tokens, start) -> Dict: """Appel OpenAI.""" response = self.openai_client.chat.completions.create( model=self.openai_model, messages=messages, temperature=temperature, max_tokens=max_tokens ) content = response.choices[0].message.content latency = time.time() - start # Calculer coût input_tokens = response.usage.prompt_tokens output_tokens = response.usage.completion_tokens cost = (input_tokens * 0.00001) + (output_tokens * 0.00003) # GPT-4 Turbo pricing self.stats["total_cost"] += cost self.stats["total_latency"] += latency self.stats["openai_only"] += 1 return { 'content': content, 'provider': 'openai', 'latency': latency, 'cost': cost, 'confidence': 1.0, 'model': self.openai_model } def _estimate_confidence(self, content: str, messages: List[Dict]) -> float: """ Estime confiance de la réponse (heuristique). En prod : utiliser modèle de scoring ou feedback utilisateur. """ # Heuristiques basiques if len(content) < 30: return 0.4 # Trop courte if any(phrase in content.lower() for phrase in [ "i don't know", "je ne sais pas", "i'm not sure", "je ne suis pas sûr", "i cannot", "je ne peux pas" ]): return 0.5 # Incertaine # Si prompt demande du code et réponse contient code fence if "```" in messages[-1]['content'] or "code" in messages[-1]['content'].lower(): if "```" in content: return 0.95 # Code présent = bon signe else: return 0.65 # Code attendu mais absent # Par défaut : confiance élevée return 0.9 def get_stats(self) -> Dict: """Retourne métriques d'utilisation.""" total = self.stats["total_requests"] if total == 0: return self.stats ollama_rate = self.stats["ollama_success"] / total fallback_rate = self.stats["ollama_fallback"] / total avg_latency = self.stats["total_latency"] / total # Estimation économies avg_cost_if_all_openai = total * 0.04 # ~4 cents/req moyenne actual_cost = self.stats["total_cost"] savings = avg_cost_if_all_openai - actual_cost return { **self.stats, "ollama_rate": f"{ollama_rate:.1%}", "fallback_rate": f"{fallback_rate:.1%}", "avg_latency": f"{avg_latency:.2f}s", "estimated_savings": f"€{savings:.2f}", "cost_reduction": f"{(savings / avg_cost_if_all_openai * 100):.1f}%" if avg_cost_if_all_openai > 0 else "N/A" } # Exemple d'utilisation if __name__ == "__main__": client = LLMClient( ollama_base_url="https://api.techdocs.example.com", enable_fallback=True, confidence_threshold=0.75 ) # Test 1 : Génération docstring (cas d'usage typique) response1 = client.chat( messages=[ { "role": "system", "content": "You are a technical documentation expert. Generate clear, concise docstrings." }, { "role": "user", "content": """Generate a Python docstring for this function: def calculate_similarity(text1: str, text2: str, method: str = "cosine") -> float: embeddings1 = get_embeddings(text1) embeddings2 = get_embeddings(text2) if method == "cosine": return cosine_similarity(embeddings1, embeddings2) elif method == "euclidean": return euclidean_distance(embeddings1, embeddings2) else: raise ValueError(f"Unknown method: {method}")""" } ], temperature=0.3 ) print(f"Response: {response1['content'][:200]}...") print(f"Provider: {response1['provider']}, Latency: {response1['latency']:.2f}s, Cost: €{response1['cost']:.4f}") # Afficher stats après 100 requêtes # ... (simulate 99 more requests) print(" 📊 Stats après 100 requêtes :") print(client.get_stats())

# feature_flags.py : contrôle rollout progressif import random import hashlib from typing import Optional class FeatureFlags: """Gestion feature flags pour rollout progressif.""" def __init__(self, rollout_percentage: int = 0): """ Args: rollout_percentage: % utilisateurs routés vers Ollama (0-100) """ self.rollout_percentage = rollout_percentage def should_use_ollama(self, user_id: str, override: Optional[bool] = None) -> bool: """ Détermine si requête doit utiliser Ollama. Args: user_id: ID utilisateur (pour distribution cohérente) override: Force Ollama (True) ou OpenAI (False) Returns: True si Ollama, False si OpenAI """ # Override manuel if override is not None: return override # Rollout progressif basé sur hash user_id (distribution uniforme) user_hash = int(hashlib.md5(user_id.encode()).hexdigest(), 16) user_bucket = user_hash % 100 # 0-99 return user_bucket < self.rollout_percentage # Intégration dans API FastAPI from fastapi import FastAPI, HTTPException, Header from pydantic import BaseModel import os app = FastAPI() # Configuration rollout (variable d'environnement) OLLAMA_ROLLOUT_PERCENTAGE = int(os.getenv("OLLAMA_ROLLOUT_PERCENTAGE", "0")) feature_flags = FeatureFlags(rollout_percentage=OLLAMA_ROLLOUT_PERCENTAGE) llm_client = LLMClient( ollama_base_url="https://api.techdocs.example.com", enable_fallback=True ) class ChatRequest(BaseModel): messages: list temperature: float = 0.7 max_tokens: int = 2000 class ChatResponse(BaseModel): content: str provider: str latency: float cost: float @app.post("/v1/chat/completions", response_model=ChatResponse) async def chat_completions( request: ChatRequest, user_id: str = Header(..., alias="X-User-ID"), force_provider: Optional[str] = Header(None, alias="X-Force-Provider") ): """ Endpoint compatible OpenAI avec rollout progressif Ollama. Headers: X-User-ID: ID utilisateur (requis) X-Force-Provider: "ollama" ou "openai" (optionnel, pour tests) """ # Déterminer provider if force_provider: use_ollama = (force_provider.lower() == "ollama") else: use_ollama = feature_flags.should_use_ollama(user_id) # Appel LLM try: if use_ollama: response = llm_client.chat( messages=request.messages, temperature=request.temperature, max_tokens=request.max_tokens ) else: response = llm_client.chat( messages=request.messages, temperature=request.temperature, max_tokens=request.max_tokens, force_provider=LLMProvider.OPENAI ) return ChatResponse(**response) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.get("/stats") async def get_stats(): """Endpoint métriques LLM.""" return llm_client.get_stats() @app.get("/health") async def health_check(): """Healthcheck.""" return {"status": "ok", "rollout_percentage": OLLAMA_ROLLOUT_PERCENTAGE} # Déploiement avec rollout progressif # Semaine 1: OLLAMA_ROLLOUT_PERCENTAGE=10 # Semaine 2: OLLAMA_ROLLOUT_PERCENTAGE=30 # Semaine 3: OLLAMA_ROLLOUT_PERCENTAGE=60 # Semaine 4: OLLAMA_ROLLOUT_PERCENTAGE=90

# Calcul ROI migration ## Coûts - Migration (6 jours tech lead @ €800/j) : €4800 - Serveur Hetzner AX102 : €109/mois - Fallback OpenAI (13% trafic) : ~€43/mois - **Coût total mensuel** : €152 ## Économies - Avant : €4200/mois - Après : €152/mois - **Économies mensuelles** : €4048 - **Économies annuelles** : €48,576 ## ROI - Investissement initial : €4800 - Payback : 4800 / 4048 = **1.2 mois** - Gains nets année 1 : €48,576 - €4800 = **€43,776** - Gains nets année 2+ : **€48,576/an** ## Amortissement hardware (alternative achat serveur) - 2× RTX 4090 : €3000 - Serveur barebones : €1500 - Total hardware : €4500 - Amortissement : 4500 / 4048 = **1.1 mois** - Après amortissement : coût = €0/mois (électricité ~€30/mois)

# prometheus.yml : configuration scraping global: scrape_interval: 15s evaluation_interval: 15s scrape_configs: # Métriques GPU NVIDIA - job_name: 'gpu' static_configs: - targets: ['dcgm-exporter:9400'] metric_relabel_configs: - source_labels: [__name__] regex: 'DCGM.*' action: keep # Métriques système (CPU, RAM, disque) - job_name: 'node' static_configs: - targets: ['node-exporter:9100'] # Métriques applicatives (custom) - job_name: 'ollama-api' static_configs: - targets: ['fastapi-app:8000'] metrics_path: '/metrics' # Alertes critiques rule_files: - 'alerts.yml' # alerts.yml groups: - name: ollama_alerts rules: # GPU temperature > 85°C - alert: GPUOverheating expr: DCGM_FI_DEV_GPU_TEMP > 85 for: 5m labels: severity: critical annotations: summary: "GPU {{ $labels.gpu }} overheating ({{ $value }}°C)" description: "Temperature above 85°C for 5 minutes" # VRAM utilization > 95% - alert: VRAMSaturation expr: (DCGM_FI_DEV_FB_USED / DCGM_FI_DEV_FB_FREE) > 0.95 for: 2m labels: severity: warning annotations: summary: "VRAM near saturation on GPU {{ $labels.gpu }}" # Latence p95 > 5s - alert: HighLatency expr: histogram_quantile(0.95, rate(llm_request_duration_seconds_bucket[5m])) > 5 for: 10m labels: severity: warning annotations: summary: "High latency p95 > 5s" # Taux erreur > 2% - alert: HighErrorRate expr: rate(llm_errors_total[5m]) / rate(llm_requests_total[5m]) > 0.02 for: 5m labels: severity: critical annotations: summary: "Error rate > 2%" # Taux fallback OpenAI > 20% - alert: HighFallbackRate expr: rate(llm_fallback_total[1h]) / rate(llm_requests_total[1h]) > 0.20 for: 30m labels: severity: warning annotations: summary: "Fallback rate > 20% (quality issues?)" description: "Check Ollama model quality or increase confidence threshold"