Guide LiteLLM : Interface unifiée pour 100+ modèles IA

Vous avez déjà voulu utiliser ChatGPT dans votre code Python ? Ou peut-être tester Claude d’Anthropic ? LiteLLM résout un problème majeur : chaque fournisseur d’IA (OpenAI, Google, Anthropic…) à sa propre façon de programmer ses modèles.

Normalement, pour utiliser différents modèles d’IA, vous devriez apprendre plusieurs syntaxes :

# Pour OpenAI - une syntaxe
openai_response = openai.chat.completions.create(...)

# Pour Google - une autre syntaxe
google_response = genai.GenerativeModel(...).generate_content(...)

# Pour Anthropic - encore différent
anthropic_response = anthropic.messages.create(...)

C’est compliqué et chronophage !

La solution LiteLLM

LiteLLM est une bibliothèque Python qui vous permet d’utiliser plus de 100 modèles d’IA avec exactement la même syntaxe. C’est comme avoir un traducteur universel pour tous les services d’IA.

Concrètement, voici ce que ça change

Au lieu d’apprendre 10 syntaxes différentes, vous n’en apprenez qu’une seule :

import litellm

# Même code pour tous les modèles - seul le nom change !
response = litellm.completion(
    model="gpt-4",  # ou "claude-4-sonnet", "gemini-2.0-flash", "ollama/llama3.2", etc.
    messages=[{"role": "user", "content": "Bonjour !"}]
)

Voici les 4 avantages principaux de l’utilisation de LiteLLM :

Simplicité : Une seule syntaxe à apprendre
Flexibilité : Changez de modèle en 2 secondes
Robustesse : Si un modèle plante, LiteLLM peut automatiquement en essayer un autre
Économies : Comparez facilement les prix entre fournisseurs

Installation de LiteLLM

Nous allons installer LiteLLM, et vous verrez, c’est très simple !

Prérequis à LiteLLM

Python version 3.8 ou plus récente sur votre ordinateur
Un éditeur de code (je recommande VS Code, mais n’importe lequel fonctionne)
10 minutes de votre temps pour suivre ce guide

Installer LiteLLM

Ouvrez votre terminal (ou invite de commande sur Windows) et tapez cette commande :

python -m venv venv
source ./venv/bin/activate  # Sur Windows : venv\Scripts\activate
pip install litellm

Attendez que l’installation se termine. Vous verrez défiler du texte, c’est normal !

Vérifier que tout fonctionne

Créez un nouveau fichier Python (par exemple test_litellm.py) et écrivez dedans :

import litellm
import pkg_resources

print("LiteLLM est installé !")

# Méthode correcte pour obtenir la version
try:
    version = pkg_resources.get_distribution("litellm").version
    print(f"Version : {version}")
except:
    print("Version : disponible (impossible de déterminer le numéro)")

# Test simple pour vérifier que ça marche
print("Test de base...")
try:
    # Test sans appel d'API (juste pour vérifier l'import)
    from litellm import completion
    print("✅ Import réussi !")
    print("✅ LiteLLM est prêt à utiliser !")
except Exception as e:
    print(f"❌ Erreur : {e}")

Exécutez ce fichier. Si vous voyez le message et un numéro de version, félicitations ! LiteLLM est correctement installé.

Exemple de sortie :

LiteLLM est installé !
Version : 1.76.3
Test de base...
✅ Import réussi !
✅ LiteLLM est prêt à utiliser !

Obtenir vos clés API

Pour utiliser les modèles d’IA, vous avez besoin de clés API. Ce sont comme des “mots de passe” qui vous donnent accès aux services d’IA.

Mais qu’est-ce qu’une clé API ? Une clé API ressemble à ça : sk-1234567890abcdef.... C’est un long code unique que les services d’IA vous donnent pour vous identifier.

Obtenir votre première clé API (OpenAI)

Allez sur platform.openai.com
Créez un compte (si vous n’en avez pas)
Cliquez sur “API keys” dans le menu settings
Cliquez sur “Create new secret key”
IMPORTANT : Copiez la clé immédiatement et sauvegardez-la (vous ne pourrez plus la voir après !)

Les variables d’environnement sont un moyen sûr de stocker vos clés sans les écrire directement dans votre code.

Sur Windows :

set OPENAI_API_KEY=sk-votre-clé-ici

Sur Mac/Linux :

export OPENAI_API_KEY="sk-votre-clé-ici"

Autres services populaires

Si vous voulez essayer d’autres modèles plus tard :

Claude (Anthropic) : console.anthropic.com
Gemini (Google) : aistudio.google.com

Chaque service a sa propre procédure d’inscription, mais le principe est le même.

Votre premier échange avec une IA

Maintenant, écrivons votre tout premier programme qui “parle” à une IA !

Exemple ultra-simple

Créez un nouveau fichier Python (par exemple mon_premier_chatbot.py) et écrivez ceci :

import litellm

# Votre premier échange avec GPT-4
response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Salut ! Comment tu t'appelles ?"}]
)

# Afficher la réponse
print(response.choices[0].message.content)

Vous devriez obtenir une réponse de ce type :

Bonjour ! Je suis l'assistant virtuel de Google, je n'ai pas de nom propre. Comment puis-je vous aider aujourd'hui ?

Explication ligne par ligne :

import litellm : On importe la bibliothèque
model="gpt-4" : On choisit le modèle GPT-4 d’OpenAI
messages=[...] : On prépare notre message
"role": "user" : On indique que c’est nous qui parlons
"content": "..." : Le texte de notre message
response.choices[0].message.content : On récupère la réponse de l’IA

Essayons avec un autre modèle

Maintenant, testons Claude d’Anthropic (si vous avez une clé API) :

import litellm

# Même code, juste le nom du modèle change !
response = litellm.completion(
    model="claude-sonnet-4-20250514",
    messages=[{"role": "user", "content": "Explique-moi Python en une phrase"}]
)

print(response.choices[0].message.content)

La magie de LiteLLM : Vous voyez ? Le code est exactement le même ! Seul le nom du modèle change.

Un exemple de réponse :

Python est un langage de programmation simple, lisible et polyvalent, idéal pour les débutants comme pour les experts, utilisé dans des domaines variés allant du développement web à l'intelligence artificielle.

Tester plusieurs modèles d’un coup

Voici un petit script qui teste 3 modèles différents avec la même question :

import litellm

# Liste des modèles à tester
modeles = ["gpt-4", "claude-sonnet-4-20250514", "gemini-pro"]
question = "Dis bonjour en français"

for modele in modeles:
    try:
        response = litellm.completion(
            model=modele,
            messages=[{"role": "user", "content": question}]
        )
        print(f"🤖 {modele}: {response.choices[0].message.content}")
    except Exception as erreur:
        print(f"❌ Problème avec {modele}: {erreur}")

Pourquoi le try/except ? Certains modèles peuvent ne pas fonctionner (clé API manquante, service indisponible…). Cette construction évite que le programme plante.

Fonctionnalités avancée

Le streaming : voir la réponse se construire en direct

Vous avez remarqué sur ChatGPT que le texte apparaît mot par mot ? C’est ce qu’on appelle le “streaming”. Voici comment l’activer :

import litellm

# On active le streaming avec stream=True
response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Raconte-moi une petite histoire"}],
    stream=True  # Le secret est ici !
)

# On affiche chaque bout de texte dès qu'il arrive
print("🤖 L'IA répond en direct :")
for morceau in response:
    # Vérifier qu'il y a du contenu
    if hasattr(morceau.choices[0].delta, 'content') and morceau.choices[0].delta.content:
        print(morceau.choices[0].delta.content, end='', flush=True)

print("\n✅ Terminé !")

Pourquoi c’est utile ? L’utilisateur voit que quelque chose se passe, même pour de longues réponses.

Créer une vraie conversation

Jusqu’ici, chaque message était indépendant. Mais comment faire pour que l’IA se souvienne de ce qu’on s’est dit ? En gardant un historique !

import litellm

# On démarre une liste pour garder toute la conversation
conversation = [
    {"role": "system", "content": "Tu es un professeur de Python très patient"},
    {"role": "user", "content": "Comment créer une liste en Python ?"}
]

# Premier échange
response = litellm.completion(model="gpt-4", messages=conversation)
reponse_ia = response.choices[0].message.content

# On ajoute la réponse de l'IA à notre historique
conversation.append({"role": "assistant", "content": reponse_ia})
print(f"🤖 IA: {reponse_ia}")

# Nouvelle question (l'IA va se souvenir du contexte !)
conversation.append({"role": "user", "content": "Et comment ajouter un élément ?"})

# Deuxième échange avec contexte
response = litellm.completion(model="gpt-4", messages=conversation)
print(f"🤖 IA: {response.choices[0].message.content}")

Le truc important : L’IA n’a pas de mémoire permanente. Il faut lui renvoyer toute la conversation à chaque fois !

Contrôler la créativité de l’IA

Vous pouvez ajuster comment l’IA répond avec ces paramètres :

import litellm

response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Écris un poème sur les chats"}],
    temperature=0.8,      # Entre 0 et 1 : plus c'est haut, plus c'est créatif
    max_tokens=100,       # Limite le nombre de mots dans la réponse
    top_p=0.9            # Contrôle la diversité du vocabulaire
)

Guide des paramètres :

temperature=0 : Réponses très prévisibles et factuelles
temperature=0.7 : Bon équilibre (recommandé)
temperature=1 : Maximum de créativité (parfois bizarre)
max_tokens : Évite les réponses trop longues

Sécurité : le système de fallback

Imaginez que vous utilisez GPT-4 dans votre application, mais que le service OpenAI tombe en panne. Votre application plante ! LiteLLM peut automatiquement essayer un autre modèle.

Comment ça marche

import litellm

# Si gpt-4 ne fonctionne pas, essaie claude-3, puis gemini-pro
response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Bonjour"}],
    fallbacks=["claude-sonnet-4-20250514", "gemini-pro"]
)

print(response.choices[0].message.content)

Ce qui se passe :

LiteLLM essaie d’abord GPT-4
Si ça échoue (panne, limite atteinte…), il essaie Claude
Si Claude échoue aussi, il essaie Gemini
Votre utilisateur ne voit rien de tout ça !

Avec des tentatives multiples

import litellm

response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Analyse ce texte"}],
    fallbacks=["claude-3-sonnet-20240229"],
    num_retries=2,        # Réessaie 2 fois avant de passer au suivant
    request_timeout=20    # Abandonne après 20 secondes
)

Pourquoi c’est génial ? Votre application devient super robuste sans effort supplémentaire !

Guide des modèles disponibles

LiteLLM fonctionne avec plus de 100 modèles ! Voici les plus populaires, organisés par fournisseur.

Les modèles OpenAI (payants mais très bons)

# Les modèles GPT - excellents pour tout faire
"gpt-5"               # 🆕 Le plus récent (août 2025) - ultra performant
"gpt-5-mini"          # 🆕 Version économique de GPT-5
"gpt-5-nano"          # 🆕 Version ultra-rapide de GPT-5
"gpt-4.1"             # 🆕 Amélioré (avril 2025) - excellent équilibre
"gpt-4o"              # Le dernier modèle, très performant
"gpt-4o-mini"         # Version économique de gpt-4o
"gpt-4"               # Le classique intelligent (mais cher)
"gpt-3.5-turbo"       # Plus économique, encore très bon

Les modèles Claude d’Anthropic (très créatifs)

# Les modèles Claude - excellents pour l'écriture
"claude-opus-4"           # 🆕 Le plus puissant (mai 2025)
"claude-sonnet-4"         # 🆕 Équilibre parfait (mai 2025)
"claude-3-5-sonnet-20241022"  # Très performant génération précédente
"claude-3-sonnet-20240229"    # Bon équilibre prix/performance
"claude-3-haiku-20240307"     # Le plus rapide et économique
"claude-3-opus-20240229"      # Puissant génération précédente

Les modèles Google Gemini (gratuits pour commencer)

# Les modèles Gemini - bons et souvent gratuits
"gemini-2.0-flash"        # 🆕 Le nouveau par défaut (janvier 2025)
"gemini-2.0-pro"          # 🆕 Expérimental - excellent pour le code
"gemini-2.0-flash-lite"   # 🆕 Version économique (février 2025)
"gemini-1.5-pro"          # Encore disponible - très performant
"gemini-1.5-flash"        # Plus rapide génération précédente
"gemini-pro"              # Version standard classique

Les modèles locaux avec Ollama (100% gratuits !)

Ollama vous permet d’utiliser des modèles directement sur votre ordinateur, sans internet :

# D'abord, installez Ollama sur votre PC
# Puis téléchargez un modèle : ollama pull llama3.2

"llama3.2"       # 🆕 Le plus récent de Meta
"llama3.1"       # Excellent modèle général
"codellama"      # Spécialisé pour le code
"mistral"        # Bon équilibre
"phi3"           # Petit et rapide
"qwen2.5"        # Très performant pour sa taille

Exemple d’utilisation locale :

import litellm

# Aucune clé API nécessaire, tout se passe sur votre PC !
response = litellm.completion(
    model="ollama/phi3", # Ajoutez ollama/ devant le nom du modèle
    messages=[{"role": "user", "content": "Explique Python simplement"}],
    streaming=True  # Active le streaming si vous voulez voir la réponse en direct
)

print(response.choices[0].message.content)

Comment choisir ?

Pour débuter : Commencez avec gemini-2.0-flash (souvent gratuit et récent)
Pour la qualité maximale : gpt-5 ou claude-opus-4 (les plus puissants de 2025)
Pour un bon équilibre : gpt-4.1 ou claude-sonnet-4 (excellents rapports qualité/prix)
Pour économiser : gpt-5-mini, claude-3-haiku ou gemini-2.0-flash-lite
Pour le code : gpt-5, gemini-2.0-pro ou claude-sonnet-4
Pour la confidentialité : Modèles Ollama (tout reste sur votre PC)
Pour tester sans limite : Modèles Ollama llama3.2 ou qwen2.5

💡 Conseil 2025 : Les modèles GPT-5 et Claude 4 sont révolutionnaires mais plus chers. Pour débuter, gemini-2.0-flash offre un excellent rapport qualité/prix !

Function Calling : créer des IA qui utilisent des outils

Le function calling permet à l’IA d’utiliser des fonctions que vous créez. C’est comme donner des “super-pouvoirs” à votre IA !

Exemple simple : une IA qui peut consulter la météo

Imaginez une IA qui peut vraiment chercher la météo au lieu de l’inventer :

import litellm
import json

# 1. On crée une fonction que l'IA pourra utiliser
def obtenir_meteo(ville):
    """Cette fonction simule un appel à une API météo"""
    # En vrai, vous appelleriez une vraie API météo ici
    meteo_fake = {
        "Paris": "Ensoleillé, 22°C",
        "Londres": "Nuageux, 15°C",
        "Tokyo": "Pluvieux, 18°C"
    }
    return meteo_fake.get(ville, "Données non disponibles")

# 2. On décrit cette fonction à l'IA
description_fonction = [
    {
        "type": "function",
        "function": {
            "name": "obtenir_meteo",
            "description": "Obtient la météo actuelle pour une ville",
            "parameters": {
                "type": "object",
                "properties": {
                    "ville": {
                        "type": "string",
                        "description": "Le nom de la ville"
                    }
                },
                "required": ["ville"]
            }
        }
    }
]

# 3. On demande à l'IA quelque chose qui nécessite cette fonction
response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Quel temps fait-il à Paris ?"}],
    tools=description_fonction,
    tool_choice="auto"  # L'IA décide si elle doit utiliser un outil
)

# 4. On vérifie si l'IA veut utiliser notre fonction
if response.choices[0].message.tool_calls:
    # L'IA veut utiliser une fonction !
    appel_fonction = response.choices[0].message.tool_calls[0]

    if appel_fonction.function.name == "obtenir_meteo":
        # On récupère les arguments que l'IA a choisis
        arguments = json.loads(appel_fonction.function.arguments)
        ville = arguments["ville"]

        # On exécute vraiment la fonction
        resultat_meteo = obtenir_meteo(ville)

        print(f"🌤️ Météo pour {ville}: {resultat_meteo}")

Ce qui se passe dans les coulisses

Vous : “Quel temps fait-il à Paris ?”
L’IA : “Je dois utiliser la fonction obtenir_meteo avec ville=‘Paris’”
Votre code : Exécute obtenir_meteo("Paris")
Résultat : L’IA a les vraies données !

Pourquoi c’est révolutionnaire ?

Avant le function calling, l’IA inventait les réponses. Maintenant, elle peut :

Consulter des bases de données
Faire des calculs complexes
Appeler des APIs externes
Contrôler des appareils
Et bien plus !

Surveiller et déboguer vos applications

Quand vous développez avec l’IA, il est important de comprendre ce qui se passe : combien ça coûte, pourquoi ça plante, etc.

Activer les logs pour voir ce qui se passe

import litellm
import logging

# Active les messages détaillés de LiteLLM
litellm.set_verbose = True

# Configure Python pour afficher tous les détails
logging.basicConfig(level=logging.DEBUG)

# Maintenant, chaque appel sera détaillé
response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Hello"}]
)

Ce que vous verrez : Les URLs appelées, les headers HTTP, les temps de réponse, etc.

Suivre vos coûts automatiquement

L’IA coûte de l’argent ! LiteLLM peut vous aider à suivre vos dépenses :

import litellm

response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Écris un article de 500 mots"}]
)

# Afficher les statistiques d'usage
if hasattr(response, 'usage'):
    usage = response.usage
    print(f"📊 Statistiques:")
    print(f"   Tokens utilisés au total: {usage.total_tokens}")
    print(f"   Tokens de votre question: {usage.prompt_tokens}")
    print(f"   Tokens de la réponse: {usage.completion_tokens}")

    # Estimation du coût (exemple pour GPT-4)
    cout_estime = (usage.prompt_tokens * 0.00003 + usage.completion_tokens * 0.00006)
    print(f"   Coût estimé: ${cout_estime:.4f}")

Pourquoi c’est important ? Vous évitez les mauvaises surprises sur votre facture !

Résoudre les problèmes courants

Tous les développeurs rencontrent des erreurs ! Voici les plus fréquentes et comment les corriger.

Erreur : “AuthenticationError” - La plus courante

Le problème : Votre clé API est incorrecte ou manquante.

Le message d’erreur exact :

**Le message d'erreur exact :**

```text
litellm.AuthenticationError: AuthenticationError: OpenAI Exception -
The api_key client option must be set either by passing api_key to the client
or by setting the OPENAI_API_KEY environment variable

Solutions étape par étape :

Vérifiez que vous avez une clé API OpenAI
- Allez sur platform.openai.com
- Connectez-vous et créez une clé API si nécessaire
Configurez la clé dans votre terminal :

Sur Windows :
Fenêtre de terminal
```
set OPENAI_API_KEY=sk-votre-vraie-clé-ici
```
Sur Mac/Linux :
Fenêtre de terminal
```
export OPENAI_API_KEY="sk-votre-vraie-clé-ici"
```

OU configurez la clé directement dans votre code :

import os
import litellm

# Remplacez par votre vraie clé !
os.environ["OPENAI_API_KEY"] = "sk-votre-vraie-clé-ici"

# Maintenant ça devrait marcher
response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Test"}]
)
print(response.choices[0].message.content)

Code de test avec gestion d’erreur :

import litellm
from litellm.exceptions import AuthenticationError

try:
    response = litellm.completion(
        model="gpt-4",
        messages=[{"role": "user", "content": "Test"}]
    )
    print("✅ Ça marche !")
    print(response.choices[0].message.content)

except AuthenticationError as erreur:
    print("🚨 Problème d'authentification !")
    print("✅ Solutions :")
    print("   1. Vérifiez votre clé API OPENAI_API_KEY")
    print("   2. Assurez-vous qu'elle commence par 'sk-'")
    print("   3. Vérifiez qu'elle n'a pas expiré")
    print("   4. Relancez votre terminal après avoir défini la variable")

Astuce importante : Après avoir défini une variable d’environnement, fermez et rouvrez votre terminal !

Erreur : “RateLimitError”

Le problème : Vous faites trop d’appels trop rapidement.

Voici une fonction qui réessaie automatiquement :

import litellm
from litellm.exceptions import RateLimitError
import time

def appel_avec_patience(model, messages, max_essais=3):
    """Fonction qui réessaie si on va trop vite"""

    for essai in range(max_essais):
        try:
            return litellm.completion(model=model, messages=messages)

        except RateLimitError:
            if essai < max_essais - 1:  # Pas le dernier essai
                attente = 2 ** essai  # 1s, 2s, 4s...
                print(f"⏳ Trop rapide ! J'attends {attente} secondes...")
                time.sleep(attente)
            else:
                print("❌ Impossible après plusieurs essais")
                raise

# Utilisation
response = appel_avec_patience(
    model="gpt-4",
    messages=[{"role": "user", "content": "Test avec patience"}]
)

Erreur : Modèle inexistant

Le problème : Le nom du modèle est incorrect.

import litellm

def appel_securise(model, messages, modele_secours="gpt-3.5-turbo"):
    """Essaie un modèle, utilise un modèle de secours si ça échoue"""
    try:
        return litellm.completion(model=model, messages=messages)
    except Exception as erreur:
        print(f"⚠️ Problème avec {model}: {erreur}")
        print(f"🔄 J'essaie {modele_secours} à la place...")
        return litellm.completion(model=modele_secours, messages=messages)

# Test avec un modèle qui n'existe pas
response = appel_securise(
    model="gpt-999-nexiste-pas",
    messages=[{"role": "user", "content": "Hello"}]
)

Projet pratique : votre chatbot intelligent

Maintenant que vous maîtrisez les bases, créons ensemble un vrai chatbot qui peut utiliser plusieurs modèles d’IA !

Fonctionnalités de notre chatbot

✅ Conversation continue (avec mémoire)
✅ Changement de modèle à la volée
✅ Commandes spéciales (comme /help)
✅ Gestion des erreurs

Le code complet expliqué

import litellm
from datetime import datetime

class ChatbotIntelligent:
    def __init__(self):
        # On stocke toute la conversation ici
        self.historique = []

        # Les modèles qu'on peut utiliser
        self.modeles_disponibles = [
            "gpt-4",
            "claude-3-sonnet-20240229",
            "gemini-pro"
        ]

        # Le modèle actuel (on commence avec GPT-4)
        self.modele_actuel = "gpt-4"

    def ajouter_message(self, qui_parle, message):
        """Ajoute un message à l'historique avec l'heure"""
        self.historique.append({
            "role": qui_parle,
            "content": message,
            "heure": datetime.now().strftime("%H:%M")
        })

    def changer_modele(self, nouveau_modele):
        """Change le modèle d'IA utilisé"""
        if nouveau_modele in self.modeles_disponibles:
            self.modele_actuel = nouveau_modele
            return f"✅ Modèle changé vers {nouveau_modele}"
        else:
            return f"❌ Modèle {nouveau_modele} non disponible"

    def gerer_commandes(self, commande):
        """Gère les commandes spéciales qui commencent par /"""

        if commande == "/help":
            return """
🤖 Commandes disponibles :
/models - Voir tous les modèles
/model <nom> - Changer de modèle
/clear - Effacer l'historique
/history - Voir le nombre de messages
/quit - Quitter le chat
            """

        elif commande == "/models":
            modeles_liste = "\n".join([f"  - {m}" for m in self.modeles_disponibles])
            return f"📋 Modèles disponibles:\n{modeles_liste}\n\n🎯 Actuel: {self.modele_actuel}"

        elif commande.startswith("/model "):
            nouveau_modele = commande.split(" ", 1)[1]
            return self.changer_modele(nouveau_modele)

        elif commande == "/clear":
            self.historique = []
            return "🧹 Historique effacé !"

        elif commande == "/history":
            return f"💬 {len(self.historique)} messages dans l'historique"

        elif commande == "/quit":
            return "QUIT"  # Signal spécial pour quitter

        else:
            return "❓ Commande inconnue. Tapez /help pour voir l'aide."

    def parler(self, message_utilisateur):
        """Fonction principale pour parler avec l'IA"""

        # Si c'est une commande spéciale
        if message_utilisateur.startswith("/"):
            return self.gerer_commandes(message_utilisateur)

        # Ajouter le message de l'utilisateur
        self.ajouter_message("user", message_utilisateur)

        # Préparer les messages pour l'IA (sans les heures)
        messages_pour_ia = [
            {"role": msg["role"], "content": msg["content"]}
            for msg in self.historique
        ]

        try:
            # Appeler l'IA
            response = litellm.completion(
                model=self.modele_actuel,
                messages=messages_pour_ia,
                temperature=0.7,
                max_tokens=300
            )

            # Récupérer la réponse
            reponse_ia = response.choices[0].message.content

            # Ajouter la réponse à l'historique
            self.ajouter_message("assistant", reponse_ia)

            return reponse_ia

        except Exception as erreur:
            return f"😔 Désolé, j'ai un problème avec {self.modele_actuel}: {erreur}"

# Fonction pour utiliser le chatbot
def demarrer_chat():
    print("🚀 Chatbot LiteLLM démarré !")
    print("Tapez /help pour voir les commandes")
    print("=" * 50)

    bot = ChatbotIntelligent()

    while True:
        # Demander à l'utilisateur
        message = input(f"\n👤 Vous: ").strip()

        # Ignorer les messages vides
        if not message:
            continue

        # Faire parler le chatbot
        reponse = bot.parler(message)

        # Vérifier si on doit quitter
        if reponse == "QUIT":
            print("👋 Au revoir !")
            break

        # Afficher la réponse
        print(f"🤖 {bot.modele_actuel}: {reponse}")

# Lancer le chatbot
if __name__ == "__main__":
    demarrer_chat()

Comment utiliser votre chatbot

Copiez ce code dans un fichier chatbot.py
Exécutez : python chatbot.py
Testez les commandes :
- Tapez /help pour voir l’aide
- Tapez /models pour voir les modèles disponibles
- Tapez /model claude-3-sonnet-20240229 pour changer de modèle
- Posez des questions normales pour discuter !

Exemples d’utilisation

👤 Vous: Salut ! Comment tu vas ?
🤖 gpt-4: Bonjour ! Je vais très bien, merci ! ...

👤 Vous: /model claude-3-sonnet-20240229
🤖 gpt-4: ✅ Modèle changé vers claude-3-sonnet-20240229

👤 Vous: Tu te souviens de ma première question ?
🤖 claude-3-sonnet-20240229: Oui, vous m'avez demandé comment j'allais...

Astuce : Le chatbot garde toute la conversation en mémoire, même quand vous changez de modèle !

Conseils pour aller plus loin

Protéger vos clés API

Règle d’or : Ne mettez jamais vos vraies clés API dans votre code !

Bonne pratique : Utilisez un fichier .env

Créez un fichier .env dans votre projet :

# Fichier .env (ne partagez JAMAIS ce fichier !)
OPENAI_API_KEY=sk-votre-vraie-clé-ici
ANTHROPIC_API_KEY=sk-ant-votre-clé-claude

Installez python-dotenv :

pip install python-dotenv

Chargez les clés depuis le fichier :

from dotenv import load_dotenv
import os

# Charge automatiquement le fichier .env
load_dotenv()

# Maintenant vos clés sont disponibles
# (sans les écrire dans le code !)

Gérer les timeouts

Parfois, l’IA met du temps à répondre. Vous pouvez définir des limites :

import litellm

# Configuration globale
litellm.request_timeout = 30  # Maximum 30 secondes
litellm.num_retries = 2       # Réessaie 2 fois en cas d'échec

response = litellm.completion(
    model="gpt-4",
    messages=[{"role": "user", "content": "Question complexe..."}]
)

Optimiser les coûts

Quelques astuces pour économiser avec les nouveaux modèles 2025 :

Utilisez max_tokens pour limiter les réponses longues
Choisissez le bon modèle : gpt-5-mini coûte beaucoup moins cher que gpt-5
Utilisez le cache pour éviter de redemander la même chose
Testez les modèles gratuits : gemini-2.0-flash est souvent gratuit !

# Exemple d'optimisation
response = litellm.completion(
    model="gpt-5-mini",     # 🆕 Plus économique que gpt-5 complet
    messages=[{"role": "user", "content": "Question courte"}],
    max_tokens=50,          # Limite la réponse
    temperature=0.3         # Moins créatif = plus prévisible = moins cher
)

Plus d’infos

Site officiel : litellm.ai - Toute l’actualité de LiteLLM
Documentation complète : docs.litellm.ai - Guide technique détaillé
Code source : GitHub BerriAI/litellm
- Pour les curieux !

Conclusion

Félicitations ! 🎉 Vous venez d’apprendre un outil qui va transformer votre façon de développer avec l’IA.

Expérimentez avec les exemples de ce guide
Testez différents modèles pour voir leurs spécialités
Construisez votre premier projet avec LiteLLM

Derniers conseils de développeur :

Commencez petit : Un simple chatbot avant de faire quelque chose de complexe
Testez toujours : Les modèles d’IA peuvent être imprévisibles
Surveillez vos coûts : L’IA peut coûter cher si on n’y fait pas attention
Amusez-vous : L’IA ouvre des possibilités infinies !

Maintenant, à vous de jouer ! Qu’allez-vous créer avec LiteLLM ?