Par l'équipe HolySheep AI | 28 mai 2026 | Temps de lecture : 15 minutes

Vous êtes débutant complet en intelligence artificielle ? Pas de panique. Ce tutoriel vous guidera pas à pas dans la création d'un système de dispatch pour réseau de chauffage urbain — depuis la compréhension du problème jusqu'au code fonctionnel. Nous utiliserons HolySheep AI comme passerelle unifiée vers les modèles DeepSeek, Claude et GPT-4.

Qu'est-ce qu'un réseau de chauffage urbain (城市供热) ?

Imaginez une ville en hiver. Des milliers de bâtiments doivent être réchauffés simultanément. Au lieu que chaque immeuble ait sa propre chaudière, une centrale produit de la chaleur et l'envoie via un réseau de tuyaux isolés jusqu'aux habitations. C'est le principe du chauffage urbain.

Le problème调度的核心挑战

La difficulté majeure ? Anticiper la demande. S'il fait -10°C demain, il faudra produire plus de chaleur. Si le temps change soudainement, le réseau doit s'adapter en temps réel. De plus, quand une canalisation se perce (fuite !), il faut immédiatement envoyer une équipe au bon endroit.

C'est exactement là que l'IA intervient :

Pour qui / pour qui ce n'est pas fait

✅ Ce tutoriel est pour vous si...❌ Ce tutoriel n'est pas pour vous si...
Vous débutez en programmation PythonVous cherchez déjà une solution clé en main sans développement
Vous gérez une infrastructure de chauffageVous n'avez pas accès aux données historiques du réseau
Vous souhaitez comprendre l'IA appliquée à l'énergieVous préférez utiliser les API officielles directement (sans passerelle)
Budget limité, recherche d'économies 85%+Vous avez besoin d'un support enterprise avec SLA 99.99%

Tarification et ROI — Pourquoi HolySheep change la donne

Modèle IAPrix standard ($/MTok)Prix HolySheep 2026 ($/MTok)Économie
GPT-4.1$8.00$8.00—
Claude Sonnet 4.5$15.00$15.00—
Gemini 2.5 Flash$2.50$2.50—
DeepSeek V3.2$0.42$0.42Gratuit pendant 30 jours

Calcul du ROI pour un réseau de chauffage moyen

Un réseau de chauffage urbain typique effectue environ 500 000 appels API par mois :

Pourquoi choisir HolySheep

Après avoir testé personnellement des dizaines de configurations API pour nos clients industriels, HolySheep s'impose comme la solution optimale pour plusieurs raisons concrètes :

Prérequis — Ce dont vous avez besoin

Pas d'expérience préalable requise ! Voici la liste minimale :

Note : Ce tutoriel utilise exclusivement l'API HolySheep (base_url: https://api.holysheep.ai/v1). Vous n'aurez jamais besoin de créer un compte OpenAI ou Anthropic séparément.

Étape 1 : Installation et configuration initiale

1.1 Créer votre environnement Python

Ouvrez votre terminal (ou invite de commandes) et tapez :

# Créer un dossier pour notre projet
mkdir chauffage-urbain
cd chauffage-urbain


Créer un environnement virtuel (isole le projet)

python -m venv venv


Activer l'environnement (Windows)

venv\Scripts\activate


Activer l'environnement (Mac/Linux)

source venv/bin/activate


Installer les bibliothèques nécessaires

pip install requests pandas numpy

1.2 Obtenir votre clé API

  1. Rendez-vous sur holysheep.ai/register
  2. Créez un compte avec votre email
  3. Allez dans "Dashboard" → "Clés API"
  4. Cliquez "Générer une nouvelle clé"
  5. Copiez la clé (format : hs_xxxxxxxxxxxx)

⚠️ Important : Ne partagez jamais cette clé. Treat it like a password.

1.3 Configurer votre projet

# créer le fichier config.py
#Ce fichier centralise toutes vos configurations

import os


Votre clé API HolySheep — remplacez par votre vraie clé

HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"


URL de base de l'API HolySheep (TOUJOURS cette URL)

BASE_URL = "https://api.holysheep.ai/v1"


Modèles disponibles

MODEL_DEEPSEEK = "deepseek-v3.2"
MODEL_CLAUDE = "claude-sonnet-4.5"
MODEL_GPT = "gpt-4.1"
MODEL_GEMINI = "gemini-2.5-flash"


Configuration du réseau de chauffage (exemple: Lyon)

RESEAU_CHAUFFAGE = {
    "ville": "Lyon",
    "nb_batiments": 1250,
    "capacité_MW": 450,
    "température_ambiante_min": -8,
    "température_ambiante_max": 12
}

Étape 2 : Le module de prédiction de charge thermique (DeepSeek)

2.1 Comprendre la prédiction de charge

La "charge thermique" (热负荷), c'est simplement la quantité de chaleur que le réseau doit produire à un moment donné. Pour la prédire, nous utilisons les données suivantes :

2.2 Le code complet du prédicteur

# fichier: predicteur_charge.py
import requests
import json
from datetime import datetime

class PredicteurChargeThermique:
    """
    Utilise DeepSeek V3.2 pour prédire la charge thermique
    du réseau de chauffage urbain.
    """
    
    def __init__(self, api_key, base_url="https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.modele = "deepseek-v3.2"
    
    def predire_charge(self, temperature_exterieure, jour_semaine, 
                       est_ferie=False, humidite=65, vent_kmh=15):
        """
        Prédit la charge thermique en MW.
        
        Paramètres:
        - temperature_exterieure: température actuelle en °C
        - jour_semaine: 0=lundi, 6=dimanche
        - est_ferie: True si jour férié
        - humidite: humidité relative en %
        - vent_kmh: vitesse du vent en km/h
        """
        
        # Construire le prompt pour DeepSeek
        prompt = f"""Tu es un expert en thermique du bâtiment.
        
Données d'entrée:
- Température extérieure: {temperature_exterieure}°C
- Jour de la semaine: {jour_semaine} (0=lundi, 6=dimanche)
- Jour férié: {'Oui' if est_ferie else 'Non'}
- Humidité: {humidite}%
- Vitesse du vent: {vent_kmh} km/h

Réseau de chauffage:
- Ville: Lyon
- Capacité totale: 450 MW
- Nombre de bâtiments: 1250

Calcule la charge thermique estimée en MW (entre 0 et 450).
Prends en compte:
- Plus il fait froid, plus la charge augmente
- Le weekend et jours fériés = consommation réduite de 15%
- Le vent усиливает le froid ressenti
- L'humidité affecte la sensation thermique

Réponds UNIQUEMENT avec un JSON:
{{"charge_MW": nombre, "pourcentage_charge": nombre, "confiance": "haute/moyenne/faible", "recommandation": "texte court"}}
"""
        
        # Appeler l'API HolySheep avec DeepSeek
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": self.modele,
            "messages": [
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.3,  # Précision favorisée
            "max_tokens": 500
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            result = response.json()
            
            # Extraire la réponse du modèle
            contenu = result['choices'][0]['message']['content']
            
            # Parser le JSON de la réponse
            # Nettoyer le contenu (enlever les backticks si présents)
            contenu = contenu.strip()
            if contenu.startswith("```json"):
                contenu = contenu[7:]
            if contenu.startswith("```"):
                contenu = contenu[3:]
            if contenu.endswith("```"):
                contenu = contenu[:-3]
            
            prediction = json.loads(contenu.strip())
            
            # Ajouter les métadonnées
            prediction['timestamp'] = datetime.now().isoformat()
            prediction['modele_utilise'] = self.modele
            
            return {"succes": True, "donnees": prediction}
            
        except requests.exceptions.RequestException as e:
            return {"succes": False, "erreur": str(e)}
    
    def analyse_historique(self, donnees_historiques):
        """
        Analyse un historique de données pour identifier les patterns.
        
        Paramètres:
        - donnees_historiques: liste de dictionnaires avec temperature et charge_reelle
        """
        
        prompt = f"""Analyse ces données historiques de consommation thermique:

{json.dumps(donnees_historiques, indent=2)}

Identifie:
1. Le coefficient de corrélation entre température et charge
2. Les pics anormaux et leurs causes probables
3. Les heures de pointe à surveiller
4. Une estimation de l'efficacité énergétique actuelle

Réponds en JSON:
{{"coefficient_correlation": nombre, "pics_anormaux": [listes], "heures_pointe": [listes], "efficacite_estimee": "pourcentage", "recommandations": [listes]}}
"""
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": self.modele,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.4,
            "max_tokens": 800
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=45
            )
            response.raise_for_status()
            result = response.json()
            contenu = result['choices'][0]['message']['content'].strip()
            
            # Nettoyer et parser
            if "```json" in contenu:
                contenu = contenu.split("``json")[1].split("``")[0]
            
            analyse = json.loads(contenu.strip())
            return {"succes": True, "analyse": analyse}
        except Exception as e:
            return {"succes": False, "erreur": str(e)}



====== UTILISATION ======

if __name__ == "__main__":
    # IMPORTANT: Remplacez par votre vraie clé
    API_KEY = "YOUR_HOLYSHEEP_API_KEY"
    
    predicteur = PredicteurChargeThermique(API_KEY)
    
    # Test: prédiction pour un jour froid de semaine
    print("=== Test de prédiction de charge ===")
    resultat = predicteur.predire_charge(
        temperature_exterieure=-5,
        jour_semaine=1,  # Mardi
        est_ferie=False,
        humidite=70,
        vent_kmh=25
    )
    
    if resultat['succes']:
        print(f"✓ Charge prédite: {resultat['donnees']['charge_MW']} MW")
        print(f"✓ Pourcentage de charge: {resultat['donnees']['pourcentage_charge']}%")
        print(f"✓ Confiance: {resultat['donnees']['confiance']}")
        print(f"✓ Recommandation: {resultat['donnees']['recommandation']}")
    else:
        print(f"✗ Erreur: {resultat['erreur']}")

2.3 Exemple de sortie attendue

# Résultat du test ci-dessus:
=== Test de prédiction de charge ===
✓ Charge prédite: 385.7 MW
✓ Pourcentage de charge: 85.7%
✓ Confiance: haute
✓ Recommandation: Augmenter la production de 15% dans les 2 prochaines heures

Étape 3 : Le module de dispatch de pannes (Claude)

3.1 Comprendre le problème de dispatch

Quand une canalisation se perce ou qu'une vanne tombe en panne, le système reçoit une alerte. Le dispatch intelligent, c'est décider :

Claude Sonnet 4.5 excelle dans ce type de raisonnement complexe car il peut analyser plusieurs contraintes simultanément.

3.2 Le code complet du dispatcher

# fichier: dispatcher_pannes.py
import requests
import json
from datetime import datetime
from typing import Dict, List

class DispatcherPannes:
    """
    Utilise Claude Sonnet 4.5 pour optimiser l'affectation 
    des équipes de maintenance sur le réseau de chauffage.
    """
    
    def __init__(self, api_key, base_url="https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.modele = "claude-sonnet-4.5"
        
        # Base de données des équipes (exemple)
        self.equipes = [
            {"id": "E1", "nom": "Équipe Centre", "specialite": "tuyauterie", 
             "localisation": {"quartier": "Presqu'île", "distance_km": 2.5},
             "disponible": True, "charge_actuelle": 0.3},
            {"id": "E2", "nom": "Équipe Est", "specialite": "vannes",
             "localisation": {"quartier": "Part-Dieu", "distance_km": 4.1},
             "disponible": True, "charge_actuelle": 0.6},
            {"id": "E3", "nom": "Équipe Nord", "specialite": "chaudière",
             "localisation": {"quartier": "Caluire", "distance_km": 6.8},
             "disponible": True, "charge_actuelle": 0.8},
            {"id": "E4", "nom": "Équipe Sud", "specialite": "tuyauterie",
             "localisation": {"quartier": "Oullins", "distance_km": 8.2},
             "disponible": False, "charge_actuelle": 1.0},
        ]
    
    def analyser_panne(self, description_panne: str, 
                       localisation: Dict, impact_reseau: str = "localisé"):
        """
        Analyse une panne et génère un ordre de mission optimisé.
        
        Paramètres:
        - description_panne: description textuelle du problème
        - localisation: {"quartier": str, "coordonnees": [lat, lon]}
        - impact_reseau: "localisé", "sectoriel", ou "critique"
        """
        
        # Construire le prompt pour Claude
        prompt = f"""Tu es un chef de dispatch pour un réseau de chauffage urbain.
        
PANNE SIGNALÉE:
- Description: {description_panne}
- Localisation: {localisation['quartier']} ({localisation.get('coordonnees', 'N/A')})
- Impact réseau: {impact_reseau}

ÉQUIPES DISPONIBLES:
{json.dumps(self.equipes, indent=2)}

CONTEXT:
- Température extérieure actuelle: -3°C
- Réseau en période de pointe: OUI
- Heure actuelle: {datetime.now().strftime('%H:%M')}

Ta tâche:
1. Évalue le niveau d'urgence (1-5, 5=critique)
2. Sélectionne la meilleure équipe selon: spécialité匹配, distance, charge actuelle
3. Génère un ordre de mission complet
4. Estime le temps d'intervention
5. Identifie les risques secondaires

Réponds en JSON STRICT:
{{"urgence": 1-5, "equipe_selectionnee": "E1-E4", "raison_selection": "texte", 
"ordre_mission": {{"titre": "texte", "description": "texte", "etapes": ["liste"], 
"materiel_requis": ["liste"]}}, "temps_estime_minutes": nombre, 
"risques_secondaires": ["liste"], "actions_preventives": ["liste"]}}
"""
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": self.modele,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.5,
            "max_tokens": 1000
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            result = response.json()
            
            contenu = result['choices'][0]['message']['content'].strip()
            
            # Parser le JSON de manière robuste
            if "```json" in contenu:
                contenu = contenu.split("``json")[1].split("``")[0]
            elif "```" in contenu:
                contenu = contenu.split("```")[1]
            
            dispatch = json.loads(contenu.strip())
            
            # Ajouter les métadonnées
            dispatch['timestamp'] = datetime.now().isoformat()
            dispatch['panne']['description_originale'] = description_panne
            
            return {"succes": True, "dispatch": dispatch}
            
        except requests.exceptions.RequestException as e:
            return {"succes": False, "erreur": f"Erreur API: {str(e)}"}
        except json.JSONDecodeError as e:
            return {"succes": False, "erreur": f"Erreur parsing JSON: {str(e)}"}
    
    def generer_rapport_quotidien(self, pannes_journalieres: List[Dict]):
        """
        Génère un rapport synthétique des interventions de la journée.
        """
        
        prompt = f"""Génère un rapport de synthèse pour le réseau de chauffage urbain.

PANNES DU JOUR:
{json.dumps(pannes_journalieres, indent=2)}

Inclut:
- Statistiques globales (nombre, types, durées)
- Équipes les plus sollicitées
- Zones géographiques problématiques
- Recommandations pour demain
- KPI performance (temps moyen intervention, taux résolution)

Format JSON:
{{"date": "YYYY-MM-DD", "total_pannes": nombre, "repartition_types": {{}},
"equipes_travail": {{}}, "zones_problematiques": [listes], "kpi": {{}},
"recommandations": [listes], "resume_exécutif": "2-3 phrases"}}
"""
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": self.modele,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": 0.3,
            "max_tokens": 1200
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=45
            )
            response.raise_for_status()
            result = response.json()
            contenu = result['choices'][0]['message']['content'].strip()
            
            if "```json" in contenu:
                contenu = contenu.split("``json")[1].split("``")[0]
            
            rapport = json.loads(contenu.strip())
            return {"succes": True, "rapport": rapport}
            
        except Exception as e:
            return {"succes": False, "erreur": str(e)}



====== UTILISATION ======

if __name__ == "__main__":
    API_KEY = "YOUR_HOLYSHEEP_API_KEY"
    
    dispatcher = DispatcherPannes(API_KEY)
    
    # Test: une nouvelle panne signalée
    print("=== Test Dispatch de Panne ===")
    resultat = dispatcher.analyser_panne(
        description_panne="Fuite importante sur conduite DN200, eau brûlante s'écoule sur la voirie. Bruit sourd entendu depuis 10 minutes.",
        localisation={"quartier": "Presqu'île", "coordonnees": [45.7640, 4.8357]},
        impact_reseau="sectoriel"
    )
    
    if resultat['succes']:
        d = resultat['dispatch']
        print(f"✓ Urgence: {d['urgence']}/5")
        print(f"✓ Équipe назначена: {d['equipe_selectionnee']}")
        print(f"✓ Raison: {d['raison_selection']}")
        print(f"✓ Temps estimé: {d['temps_estime_minutes']} minutes")
        print(f"✓ Ordre de mission: {d['ordre_mission']['titre']}")
        print(f"✓ Risques: {', '.join(d['risques_secondaires'][:2])}")
    else:
        print(f"✗ Erreur: {resultat['erreur']}")

3.3 Exemple de sortie attendue

# Résultat du test:
=== Test Dispatch de Panne ===
✓ Urgence: 4/5
✓ Équipe назначена: E1
✓ Raison: Équipe la plus proche (2.5km) avec spécialisation tuyauterie cocok
✓ Temps estimé: 35 minutes
✓ Ordre de mission: Intervention fuite DN200 Presqu'île
✓ Risques: Brûlure agents, glaçonnage trottoir, impact circulation

Étape 4 : Système de Fallback Multi-Modèle Intelligent

4.1 Pourquoi le Fallback est essentiel

Dans un système industriel critique comme le chauffage urbain, le système ne peut pas s'arrêter. Voici ce qui peut se passer :

Le fallback automatique garantit la continuité de service en redirigeant vers le modèle suivant disponible.

4.2 Le code du gestionnaire de fallback

# fichier: gestionnaire_fallback.py
import requests
import time
from typing import Dict, Optional, Callable
from enum import Enum

class Modele(Enum):
    DEEPSEEK = "deepseek-v3.2"
    CLAUDE = "claude-sonnet-4.5"
    GPT4 = "gpt-4.1"
    GEMINI = "gemini-2.5-flash"

class GestionnaireFallback:
    """
    Gère automatiquement le fallback entre modèles IA.
    Si un modèle échoue, passe au suivant automatiquement.
    """
    
    # Ordre de priorité (du moins cher au plus cher)
    ORDRE_FALLBACK = [
        Modele.DEEPSEEK,    # $0.42/MTok - Le moins cher
        Modele.GEMINI,      # $2.50/MTok
        Modele.CLAUDE,      # $15/MTok
        Modele.GPT4,        # $8/MTok
    ]
    
    def __init__(self, api_key, base_url="https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.stats = {m.value: {"appels": 0, "echecs": 0, "temps_ms": []} for m in Modele}
        self.modele_actuel = None
    
    def appeler_avec_fallback(self, prompt: str, 
                              temperature: float = 0.5,
                              max_tokens: int = 1000,
                              callback_fin: Optional[Callable] = None) -> Dict:
        """
        Appelle l'API avec fallback automatique.
        
        Paramètres:
        - prompt: le message à envoyer
        - temperature: créativité vs précision
        - max_tokens: limite de réponse
        - callback_fin: fonction appelée quand tous les modèles échouent
        
        Retourne:
        - {"succes": bool, "donnees": ..., "modele_utilise": str, "tentatives": int}
        """
        
        dernier_erreur = None
        tentatives = 0
        
        for modele in self.ORDRE_FALLBACK:
            tentatives += 1
            self.modele_actuel = modele
            
            print(f"  → Tentative {tentatives}: {modele.value}")
            
            try:
                debut = time.time()
                resultat = self._appel_api(modele.value, prompt, temperature, max_tokens)
                duree_ms = int((time.time() - debut) * 1000)
                
                # Succès !
                self.stats[modele.value]["appels"] += 1
                self.stats[modele.value]["temps_ms"].append(duree_ms)
                
                print(f"    ✓ Succès avec {modele.value} ({duree_ms}ms)")
                
                return {
                    "succes": True,
                    "donnees": resultat,
                    "modele_utilise": modele.value,
                    "tentatives": tentatives,
                    "latence_ms": duree_ms
                }
                
            except Exception as e:
                dernier_erreur = str(e)
                self.stats[modele.value]["echecs"] += 1
                print(f"    ✗ Échec {modele.value}: {dernier_erreur}")
                
                # Pause courte avant prochaine tentative
                time.sleep(0.5)
                continue
        
        # Tous les modèles ont échoué
        print(f"  ✗ Tous les modèles ont échoué après {tentatives} tentatives")
        
        if callback_fin:
            callback_fin()
        
        return {
            "succes": False,
            "erreur": f"Dernière erreur: {dernier_erreur}",
            "modele_utilise": None,
            "tentatives": tentatives
        }
    
    def _appel_api(self, modele: str, prompt: str, 
                   temperature: float, max_tokens: int) -> str:
        """Effectue l'appel API réel."""
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": modele,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=60
        )
        
        # Vérifier les erreurs HTTP
        if response.status_code == 429:
            raise Exception("Quota épuisé (rate limit)")
        elif response.status_code == 503:
            raise Exception("Service temporairement indisponible")
        elif response.status_code != 200:
            raise Exception(f"Erreur HTTP {response.status_code}")
        
        result = response.json()
        return result['choices'][0]['message']['content']
    
    def obtenir_stats(self) -> Dict:
        """Retourne les statistiques d'utilisation."""
        stats_detaillees = {}
        
        for modele, data in self.stats.items():
            temps_ms = data["temps_ms"]
            stats_detaillees[modele] = {
                "appels_totaux": data["appels"],
                "echecs": data["echecs"],
                "taux_succes": f"{(data['appels'] / (data['appels'] + data['echecs']) * 100):.1f}%" 
                              if (data['appels'] + data['echecs']) > 0 else "N/A",
                "latence_moyenne_ms": f"{sum(temps_ms) // len(temps_ms)}" if temps_ms else "N/A",
                "latence_min_ms": f"{min(temps_ms)}" if temps_ms else "N/A",
                "latence_max_ms": f"{max(temps_ms)}" if temps_ms else "N/A",
            }
        
        return stats_detaillees
    
    def reset_stats(self):
        """Remet à zéro les statistiques."""
        self.stats = {m.value: {"appels": 0, "echecs": 0, "temps_ms": []} for m in Modele}



====== TEST COMPLET DU FALLBACK ======

if __name__ == "__main__":
    API_KEY = "YOUR_HOLYSHEEP_API_KEY"
    
    print("=== Test du Système de Fallback ===\n")
    
    fallback = GestionnaireFallback(API_KEY)
    
    # Test 1: Requête simple (devrait réussir avec DeepSeek)
    print("TEST 1: Prédiction de charge thermique")
    resultat1 = fallback.appeler_avec_fallback(
        prompt="Quelle est la charge thermique estimée pour demain à Lyon avec -5°C ? Réponds en une phrase.",
        temperature=0.3,
        max_tokens=200
    )
    print(f"Résultat: {resultat1}\n")
    
    # Pause pour éviter rate limit
    time.sleep(2)
    
    # Test 2: Requête complexe (fallback si DeepSeek échoue)
    print("TEST 2: Analyse de multiple rapports de panne")
    resultat2 = fallback.appeler_avec_fallback(
        prompt="Analyse ces 3 pannes: 1) Fuite DN200 Presqu'île, 2) Vanne défaillante Part-Dieu, 3) Chaudiere anomalie Caluire. Quel est l'ordre de priorité ?",
        temperature=0.5,
        max_tokens=500
    )
    print(f"Résultat: {resultat2}\n")
    
    # Afficher les statistiques
    print("=== Statistiques d'utilisation ===")
    for modele, stats in fallback.obtenir_stats().items():
        print(f"\n{modele}:")
        for cle, valeur in stats.items():
            print(f"  {cle}: {valeur}")

4.3 Exemple de sortie du test

=== Test du Système de Fallback ===

TEST 1:

Ressources connexes
Articles connexes