LiteLLM : une seule API pour GPT, Claude et Mistral — guide pratique pour développeurs

Tu as déjà eu envie de tester ton code avec GPT, puis de basculer sur Claude ou Mistral sans tout réécrire ? C’est exactement le problème que résout LiteLLM, une bibliothèque Python devenue en quelques années un standard de fait pour les développeurs qui construisent des applications d’IA. Dans ce guide pratique, tu vas apprendre à l’installer, à appeler plusieurs modèles avec la même fonction, à gérer le streaming, les erreurs et le coût — avec du code que tu peux copier-coller et exécuter immédiatement.

1. Pourquoi LiteLLM ? Le problème du vendor lock-in

Chaque fournisseur d’IA a son SDK, ses paramètres, sa gestion d’erreurs. Pour utiliser OpenAI, tu importes openai ; pour Anthropic, anthropic ; pour Mistral, mistralai. Changer de modèle = changer de code. C’est ce qu’on appelle le vendor lock-in : tu es captif d’un fournisseur, et tu ne peux pas facilement comparer les modèles entre eux ou basculer vers l’offre la plus intéressante.

LiteLLM résout ce problème en proposant une seule interface pour plus de 100 fournisseurs (OpenAI, Anthropic, Mistral, Google Gemini, Cohere, Ollama pour le local, et bien d’autres). Le principe est simple : tu écris ton code une fois, et tu changes de modèle en modifiant une simple chaîne de caractères.

Pour un développeur, c’est un gain de temps énorme : plus besoin d’apprendre trois SDK différents, plus besoin de maintenir trois blocs de gestion d’erreurs, et tu peux benchmarker les modèles côte à côte en quelques minutes.

2. Installation et premier appel

L’installation se fait avec pip, comme n’importe quelle bibliothèque Python :

pip install litellm

Puis le premier appel, avec le modèle GPT-4o d’OpenAI :

import litellm

response = litellm.completion(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Tu es un assistant expert en Python."},
        {"role": "user", "content": "Explique-moi les list comprehensions en une phrase."},
    ],
)

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

Rien de révolutionnaire jusque-là, me diras-tu. La magie arrive maintenant : pour passer sur Claude, tu changes uniquement le nom du modèle :

response = litellm.completion(
    model="claude-3-5-sonnet-20241022",
    messages=[
        {"role": "system", "content": "Tu es un assistant expert en Python."},
        {"role": "user", "content": "Explique-moi les list comprehensions en une phrase."},
    ],
)

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

Et pour Mistral, même chose :

response = litellm.completion(
    model="mistral/mistral-large-latest",
    messages=[{"role": "user", "content": "Bonjour !"}],
)

L’API de réponse est identique à celle d’OpenAI (response.choices[0].message.content), quelle que soit la marque du modèle. C’est tout l’intérêt : tu n’apprends qu’une seule interface.

3. Gérer les clés API proprement

LiteLLM lit automatiquement les variables d’environnement conventionnelles : OPENAI_API_KEY, ANTHROPIC_API_KEY, MISTRAL_API_KEY, GEMINI_API_KEY, etc. Tu peux aussi passer la clé directement dans l’appel :

import os
from dotenv import load_dotenv

load_dotenv()  # charge .env

response = litellm.completion(
    model="gpt-4o",
    api_key=os.getenv("OPENAI_API_KEY"),
    messages=[{"role": "user", "content": "Dis bonjour"}],
)

Règle d’or : ne mets jamais une clé API en dur dans ton code. Utilise un fichier .env (avec python-dotenv) ou les variables d’environnement de ton déploiement. Et ajoute .env à ton .gitignore dès la création du projet.

4. Streaming : afficher les réponses en temps réel

Les chatbots modernes affichent la réponse token par token. Avec LiteLLM, c’est un paramètre :

response = litellm.completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Écris un haïku sur Python."}],
    stream=True,
)

for chunk in response:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Le flux est itéré chunk par chunk, exactement comme avec le SDK OpenAI natif. Tu peux ensuite brancher ça sur une interface Streamlit ou FastAPI + Server-Sent Events pour créer un vrai chatbot web.

5. Sortie structurée JSON : des données fiables pour ton app

Un besoin fréquent en production : obtenir une réponse structurée en JSON plutôt qu’un texte libre, pour l’intégrer directement dans une base de données ou une API. LiteLLM gère ça avec response_format :

response = litellm.completion(
    model="gpt-4o",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Réponds uniquement en JSON valide."},
        {"role": "user", "content": "Extrais le nom, le prix et la disponibilité de ce produit : 'Casque audio sans fil, 89,90 €, en stock'."},
    ],
)

import json
data = json.loads(response.choices[0].message.content)
print(data["name"], data["price"])

Combiné à Pydantic, tu peux même valider automatiquement la structure de la réponse et typer les champs :

from pydantic import BaseModel
import json

class Produit(BaseModel):
    name: str
    price: float
    in_stock: bool

data = json.loads(response.choices[0].message.content)
produit = Produit(**data)  # validation + typage
print(produit.price + 10)

Fini les réponses imprévisibles : si le modèle renvoie un champ manquant ou un mauvais type, Pydantic lève une erreur claire et tu peux relancer l’appel ou gérer le cas proprement.

6. Retry automatique et gestion des erreurs

Les APIs de modèles sont sujettes aux erreurs transitoires : rate limits (429), serveurs saturés (503), timeouts. LiteLLM intègre une logique de retry avec backoff exponentiel prête à l’emploi :

import litellm

response = litellm.completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Bonjour"}],
    num_retries=3,          # 3 tentatives en cas d'échec
    timeout=30,             # timeout par appel en secondes
)

# Gestion d'erreurs explicite
try:
    response = litellm.completion(model="gpt-4o", messages=[{"role": "user", "content": "Bonjour"}])
except litellm.exceptions.RateLimitError as e:
    print("Rate limit atteint :", e)
except litellm.exceptions.Timeout as e:
    print("Timeout :", e)

En production, ajoute toujours num_retries et un timeout raisonnable. Un appel sans timeout peut geler ton serveur web pendant des minutes si l’API ne répond pas.

7. Maîtriser les coûts : budgets et limites

Les appels LLM coûtent de l’argent. LiteLLM permet de définir des budgets par appel ou par utilisateur pour éviter les mauvaises surprises :

response = litellm.completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Génère un long texte"}],
    max_budget=0.05,   # 5 centimes max pour cet appel
)

# Coût estimé de l'appel
print("Coût estimé :", response._hidden_params.get("response_cost"), "€")

Astuce coût : pour les tâches simples (classification, extraction courte), utilise un petit modèle rapide (gpt-4o-mini, mistral-small) et réserve les gros modèles aux tâches complexes. C’est la stratégie que les équipes sérieuses appliquent : le bon modèle pour chaque tâche, pas le plus gros modèle pour tout.

8. Aller plus loin : le local avec Ollama

Enfin, LiteLLM fonctionne aussi avec des modèles 100% locaux via Ollama — pratique pour développer sans dépenser un centime ou pour les données sensibles :

# Une fois Ollama installé : ollama pull llama3.2
response = litellm.completion(
    model="ollama/llama3.2",
    messages=[{"role": "user", "content": "Raconte une blague de développeur."}],
    api_base="http://localhost:11434",
)

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

Le même code tourne avec un modèle local ou un modèle cloud : il suffit de changer la chaîne model. C’est parfait pour développer gratuitement en local, puis passer en production sur un modèle cloud sans toucher au code.

9. Récapitulatif : quand utiliser LiteLLM ?

LiteLLM brille dès que ton projet dépasse le simple script de test :

• Tu veux comparer plusieurs modèles (GPT, Claude, Mistral, Gemini) sur tes propres cas d’usage.
• Tu construis une application multi-modèles : un même prompt, plusieurs moteurs d’IA derrière.
• Tu veux une couche de retry, timeout et budget sans réinventer la roue.
• Tu veux passer du local au cloud sans réécrire ton code.

À l’inverse, si tu n’utilises qu’un seul fournisseur pour un prototype jetable, le SDK natif suffit amplement. LiteLLM prend tout son sens quand ton application devient sérieuse et que la flexibilité devient un atout.

Conclusion

LiteLLM est devenu un outil indispensable dans la boîte à outils du développeur IA : une seule API pour des dizaines de modèles, le streaming en trois lignes, les retries automatiques, les budgets et même le local avec Ollama. En maîtrisant cette bibliothèque, tu gagnes en autonomie et tu peux toujours choisir le meilleur modèle pour ton besoin — sans dépendre d’un fournisseur unique.

Tu veux progresser sur les bases du langage qui fait tourner tous ces exemples ? Le cours Python — Les Fondamentaux te donne les fondations solides pour écrire du code propre et maintenable, avant de t’attaquer aux APIs d’IA.