LiteLLM : Un guide avec des exemples pratiques

Le passage d'un fournisseur LLM à un autre ne devrait pas nécessiter la réécriture de l'ensemble de votre base de code. Cependant, c'est précisément ce qui se produit lorsque l'on utilise plusieurs services d'IA aujourd'hui. Chaque fournisseur dispose de son propre SDK, de sa propre méthode d'authentification et de son propre format de réponse. LiteLLM résout ce problème grâce à une interface unifiée.

Dans ce tutoriel, je vais vous présenter les principaux composants de LiteLLM et vous expliquer comment commencer par des appels API de base, puis passer aux réponses en streaming, aux sorties structurées et au suivi des coûts.

Qu'est-ce que LiteLLM ?

LiteLLM est une bibliothèque Python open source qui agit comme un traducteur universel pour les modèles d'IA. Au lieu d'apprendre différentes API pour chaque fournisseur, vous pouvez utiliser une seule interface qui se connecte à plus de 100 services LLM.

Le cadre comporte deux parties principales. Le SDK Python vous permet d'écrire du code une seule fois et de l'exécuter avec n'importe quel fournisseur. Le serveur proxy sert de passerelle centrale pour les équipes et les entreprises qui ont besoin de gérer des services d'IA à grande échelle.

LiteLLM vous offre les avantages supplémentaires suivants :

• s intégrées de suivi des coûts: Consultez les dépenses de tous les fournisseurs sur un seul tableau de bord au lieu de vérifier plusieurs systèmes de facturation.
• Basculement automatique: Lorsqu'un fournisseur rencontre des difficultés ou atteint ses limites de débit, LiteLLM active automatiquement vos options de secours.
• Option d'hébergement autonome: Si vous avez besoin de confidentialité ou de conformité des données, veuillez exécuter toutes les opérations sur vos propres serveurs.

Veuillez noter que OpenRouter offre un accès unifié similaire à plusieurs LLM, mais avec des tarifs et des fonctionnalités différents.

Le serveur proxy permet de définir des limites de dépenses par équipe, de suivre l'utilisation dans tous les projets et de centraliser la gestion des clés API. Toute la configuration s'effectue à l'aide de fichiers YAML simples.

LiteLLM convient à différents types d'utilisateurs :

• Développeurs individuels qui souhaitent tester plusieurs modèles sans avoir à créer de comptes partout
• Les petites équipes qui ont besoin de visibilité sur les coûts et ne souhaitent pas être liées à un fournisseur
• Les grandes entreprises qui ont besoin d'une gestion centralisée, d'un contrôle budgétaire et d'analyses détaillées de l'utilisation

La bibliothèque est sous licence MIT et entièrement open source. Vous pouvez examiner le code, le modifier selon vos besoins ou contribuer au projet.

Maintenant que vous connaissez les capacités de LiteLLM, voici comment configurer votre environnement.

Conditions préalables

Avant de pouvoir commencer à utiliser LiteLLM, il est nécessaire de procéder à quelques réglages. Si vous avez déjà travaillé avec des modèles d'IA, la plupart de ces étapes sont probablement déjà réalisées.

Environnement Python

Il est nécessaire de disposer de Python 3.7 ou d'une version plus récente. La plupart des systèmes actuels disposent de cette fonctionnalité, mais vous pouvez vérifier votre version à l'aide de la commande suivante :

import sys
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

Installation du package

Veuillez installer LiteLLM et python-dotenv pour gérer les variables d'environnement :

uv add litellm python-dotenv
# or with pip: pip install litellm python-dotenv

Clés API

Vous aurez besoin des clés API des fournisseurs que vous souhaitez utiliser. Pour ce tutoriel, nous utiliserons deux modèles :

• Clé API OpenAI : Vous pouvez obtenir une clé sur platform.openai.com (pour GPT-5).
• Clé API Anthropic : Vous pouvez obtenir une clé sur console.anthropic.com (pour Claude Sonnet 4).

Veuillez enregistrer ces éléments dans un fichier .env situé dans le répertoire de votre projet :

OPENAI_API_KEY=your_openai_key_here
ANTHROPIC_API_KEY=your_anthropic_key_here

Contrôle de l'environnement

Veuillez exécuter ce script pour vérifier votre configuration :

import os
import sys
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Check Python version
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

# Check LiteLLM
try:
   import litellm
   print("✓ LiteLLM installed")
except ImportError:
   print("✗ LiteLLM not installed")

# Check API keys
openai_key = os.getenv("OPENAI_API_KEY")
anthropic_key = os.getenv("ANTHROPIC_API_KEY")

if openai_key:
   print(f"✓ OpenAI API key found")
else:
   print("✗ OpenAI API key not found")

if anthropic_key:
   print(f"✓ Anthropic API key found")
else:
   print("✗ Anthropic API key not found")

Python version: 3.11
✓ LiteLLM installed
✓ OpenAI API key found
✓ Anthropic API key found

Si vous voyez uniquement des coches vertes, vous êtes prêt à commencer. Si l'une des vérifications échoue, veuillez vous assurer que vous avez installé les paquets et ajouté vos clés API au fichier .env.

Effectuer votre premier appel API avec LiteLLM

LiteLLM utilise la même interface que celle que vous connaissez peut-être déjà grâce à OpenAI, mais elle est compatible avec tous les fournisseurs.

Configuration de base

Veuillez commencer par ces importations :

import litellm
from dotenv import load_dotenv

# Load your API keys
load_dotenv()

Une requête de base adressée à GPT-5 suit ce modèle : définissez vos messages, appelez litellm.completion() et obtenez la réponse.

messages = [
   {"role": "user", "content": "Write a simple Python function that adds two numbers"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

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

def add(a, b):
   """Return the sum of a and b."""
   return a + b

Vous venez de contacter GPT-5 via LiteLLM. L'objet de réponse suit le format d'OpenAI, donc si vous avez déjà utilisé leur API, cela vous semblera familier. Il est possible que vous souhaitiez vérifier quel modèle a réellement répondu et contrôler l'utilisation des jetons :

print(f"Model used: {response.model}")
print(f"Response ID: {response.id}")
print(f"Total tokens: {response.usage.total_tokens}")

Model used: gpt-5-2025-08-07
Response ID: chatcmpl-CIbZWUDE1amW2vHtHDmieTX6hnZUq
Total tokens: 557

Changement de fournisseur

La véritable puissance de LiteLLM se révèle lors du changement de fournisseur. Souhaitez-vous essayer plutôt Claude Sonnet 4? Veuillez modifier un paramètre :

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages
)

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

Here's a simple Python function that adds two numbers:

def add_numbers(a, b):
   """
   Adds two numbers and returns the result.
  
   Args:
       a: First number
       b: Second number
  
   Returns:
       The sum of a and b
   """
   return a + b

# Example usage:
result = add_numbers(5, 3)
print(result)  # Output: 8

This function:
- Takes two parameters a and b
- Returns their sum using the + operator
- Works with integers, floats, and even negative numbers
- Includes a docstring to explain what the function does

Même structure de code, fournisseur différent. Claude fournit une réponse beaucoup plus détaillée, accompagnée de documentation et d'exemples, tandis que GPT-5 était plus concis.

Gestion des erreurs de base

Veuillez ajouter une gestion des erreurs pour les cas où des problèmes surviennent :

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages
   )
   print(response.choices[0].message.content)
except Exception as e:
   print(f"API call failed: {e}")

Ce modèle détecte les problèmes courants tels que les clés API non valides, les problèmes de réseau ou l'indisponibilité des modèles.

Quelle est la prochaine étape ?

Vous connaissez désormais le modèle de base pour utiliser LiteLLM avec n'importe quel fournisseur. La documentation « Pour commencer » fournit davantage de détails sur les modèles et paramètres pris en charge, tandis que la référence de la fonction « Complétion » présente toutes les options disponibles.

Pour développer des applications de production, il est également recommandé de suivre les meilleures pratiques en matière de conception d'API afin de créer des systèmes fiables et performants.

Changement de fournisseur et solutions de repli

Le système de secours de LiteLLM gère automatiquement les défaillances des fournisseurs afin que vos utilisateurs ne voient jamais de messages d'erreur. Lorsque vous développez des applications réelles, il est nécessaire de disposer de plans de secours qui fonctionnent sans nécessiter de code supplémentaire de votre part.

Configuration de secours de base

Pour configurer une solution de secours, veuillez ajouter une liste d' fallbacks s à votre appel de complétion :

messages = [
   {"role": "user", "content": "Explain what a Python decorator is in one sentence"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514"]
)

print(f"Response: {response.choices[0].message.content}")
print(f"Model used: {response.model}")

Response: A Python decorator is a callable that wraps another function or class to augment its behavior and returns it, applied with the @ syntax so you can add reusable functionality without changing the original code.
Model used: gpt-5-2025-08-07

Si GPT-5 échoue, LiteLLM essaie automatiquement Claude Sonnet 4. Les utilisateurs reçoivent une réponse dans tous les cas.

Création de chaînes de secours

Il est possible de relier plusieurs fournisseurs pour une plus grande fiabilité. En utilisant les mêmes messages que précédemment :

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514", "gpt-3.5-turbo"]
)

print(f"Model used: {response.model}")

Model used: gpt-5-2025-08-07

LiteLLM teste les modèles dans l'ordre. Si le primaire échoue, il tente le premier repli. Si cela échoue, il tente le deuxième. Plusieurs niveaux de protection.

Ajout de tentatives supplémentaires

Combinez les solutions de secours avec des tentatives répétées pour une fiabilité encore plus grande :

response = litellm.completion(
   model="gpt-5",
   messages=messages,  # Same messages as before
   num_retries=2
)

Réessaie deux fois le même modèle avant de passer aux solutions de secours. Recommandé en cas de problèmes réseau temporaires ou de pics de limitation de débit.

Les solutions de secours gèrent automatiquement la plupart des échecs, mais il est recommandé de prévoir des cas où tous les modèles échouent :

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages,  # Same messages as before
       fallbacks=["anthropic/claude-sonnet-4-20250514"],
       num_retries=2
   )
   return response.choices[0].message.content
except Exception as e:
   # All models failed - handle gracefully
   return "Sorry, I'm having trouble right now. Please try again."

Même lorsque les fournisseurs fonctionnent parfaitement, les utilisateurs sont toujours confrontés à un autre problème : les délais d'attente frustrants. Une personne clique sur « Soumettre » dans votre application et n'observe aucun résultat pendant plusieurs secondes. Ils se demandent si quelque chose s'est cassé.

Diffusion en continu pour des réponses en temps réel

La plupart des réponses des API d'IA arrivent sous la forme d'un bloc complet, comme lors du téléchargement d'un fichier. Les utilisateurs attendent sans retour d'information jusqu'à ce que la réponse complète soit prête. Le streaming modifie cela en affichant le texte au fur et à mesure de sa génération, mot par mot.

Pourquoi le streaming modifie l'expérience utilisateur

Au lieu d'attendre la réponse complète, le streaming affiche le texte au fur et à mesure que l'IA le génère. Observez la différence :

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "What is Python in one sentence?"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   stream=True
)

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

Python is a high-level, interpreted, dynamically typed, general-purpose programming language known for its readability and vast ecosystem, used across web development, data science, automation, scripting, and more.

Le texte apparaît progressivement plutôt que tout à la fois (lorsque vous exécutez l'extrait ci-dessus sur votre ordinateur). Les utilisateurs constatent immédiatement les progrès réalisés, ce qui leur donne une impression de réactivité bien plus grande que lorsqu'ils observent une icône de chargement.

Comment fonctionne réellement le streaming

Ceci fonctionne au niveau des blocs. Au lieu d'une seule réponse importante, vous recevez de nombreuses petites réponses, appelées deltas. Parfois, les blocs sont vides, il est donc important de les traiter correctement pour des raisons de sécurité :

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=[{"role": "user", "content": "Define JavaScript in exactly two sentences"}],
   stream=True
)

for chunk in response:
   if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
       print(f"'{chunk.choices[0].delta.content}'", end=" ")

'JavaScript is a high' '-level, interpreted programming language primarily used for creating' ' interactive and dynamic content on web pages, running' ' in web browsers to manip' 'ulate HTML elements, handle user events' ', and communicate with servers.' ' Originally designed for client-side web development, JavaScript has evolve' 'd into a versatile language that can also' ' be used for server-side development, mobile applications' ', and desktop software through various runtime' ' environments like Node.js.'

Rendre le streaming réutilisable

Pour les applications réelles, il est recommandé de capturer la réponse complète tout en continuant à afficher la sortie en continu. Voici une fonction permettant d'effectuer cette opération :

def stream_and_capture(model, messages):
   """Stream response while capturing the complete text"""
   response = litellm.completion(
       model=model,
       messages=messages,
       stream=True
   )
  
   full_response = ""
   for chunk in response:
       if chunk.choices[0].delta.content:
           content = chunk.choices[0].delta.content
           print(content, end="", flush=True)
           full_response += content
  
   print()  # New line after response
   return full_response

# Test it
messages = [{"role": "user", "content": "Define APIs in 2 sentences max"}]
result = stream_and_capture("gpt-5", messages)

APIs (Application Programming Interfaces) are standardized contracts, often exposed as endpoints, that specify how software components or services can communicate, including the allowed operations, inputs, and outputs. They let developers access functionality or data without knowing the underlying implementation, enabling modular, interoperable systems.

Le paramètre end="" empêche les sauts de ligne entre les blocs. flush=True force l'affichage immédiat au lieu de la mise en mémoire tampon.

Diffusion en continu avec solutions de repli

Il est également possible de combiner le streaming avec le système de secours pour une meilleure fiabilité :

response = litellm.completion(
   model="gpt-5",
   messages=[{"role": "user", "content": "Define machine learning in one sentence"}],
   fallbacks=["anthropic/claude-sonnet-4-20250514"],
   stream=True
)

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

Machine learning is a branch of artificial intelligence where algorithms learn patterns from data to make predictions or decisions without being explicitly programmed.

Retour d'information immédiat et changement automatique de fournisseur en cas de défaillance du modèle principal.

Le streaming offre aux utilisateurs un retour immédiat, mais vous rencontrez toujours un autre problème lors de la création d'applications réelles. Une fois ce texte reçu, votre code doit être en mesure de le traiter. Vous pouvez extraire des données, stocker des informations dans des bases de données ou transmettre des valeurs à d'autres fonctions. Cependant, l'analyse des réponses textuelles est complexe et peut facilement échouer lorsque le format est modifié.

Utilisation des sorties structurées

Voici ce qui se produit réellement : Vous développez une application qui analyse les commentaires des clients. Votre IA renvoie un texte tel que « Le sentiment est positif avec un niveau de confiance de 0,85 et les mots-clés principaux sont : réactif, utile, rapide. » Vous rédigez des expressions régulières pour extraire le score de confiance et les mots-clés. Tout fonctionne correctement lors des tests.

Ensuite, l'IA modifie légèrement le format de sa réponse pour indiquer « Sentiment : positif (confiance : 0,85). Les mots clés incluent réactif, serviable et rapide. Votre expression régulière ne fonctionne pas correctement. Votre pipeline de données cesse de fonctionner. Les rapports sur le sentiment des clients affichent des valeurs vides au lieu des scores. Votre tableau de bord rencontre des difficultés. Vous passez des heures à corriger du code d'analyse syntaxique qui fonctionnait correctement hier.

Les sorties structurées évitent ce problème en renvoyant les données dans des formats prévisibles dès le départ.

Obtenir JSON au lieu de texte

LiteLLM peut renvoyer du JSON au lieu de texte brut. Vous lui indiquez la structure souhaitée via votre invite, et il vous renvoie le résultat correctement formaté :

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Describe Python as a programming language. Return as JSON with fields: language, difficulty, description"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

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

{
 "language": "Python",
 "difficulty": "Beginner-friendly (easy to learn, moderate to master)",
 "description": "Python is a high-level, interpreted, dynamically typed, general-purpose programming language focused on readability and developer productivity. It supports multiple paradigms (object-oriented, functional, procedural), uses indentation for block structure, and includes a large standard library with an extensive third-party ecosystem (PyPI). Common uses include web development, data science, machine learning, automation/scripting, scientific computing, and DevOps. While not the fastest for CPU-bound tasks, it integrates well with C/C++ and accelerators, and runs cross-platform."
}

Cette approche structurée élimine les problèmes courants d'analyse syntaxique. Au lieu de rechercher dans le texte, vous obtenez un JSON valide contenant exactement les champs que vous avez demandés. Aucun problème d'analyse syntaxique, aucune surprise au niveau du format.

Utilisation des données JSON

Les chaînes JSON brutes ne sont utiles qu'une fois converties en objets Python avec lesquels votre application peut fonctionner. Il est nécessaire de convertir cette chaîne en objets Python que vous pouvez réellement utiliser :

import json

messages = [{"role": "user", "content": "Describe JavaScript in 2 sentences. Return as JSON with fields: name, paradigm, use_cases (array of exactly 3 items)"}]

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse the JSON response
data = json.loads(response.choices[0].message.content)
print(f"Language: {data['name']}")
print(f"Paradigm: {data['paradigm']}")
print(f"Use cases: {', '.join(data['use_cases'])}")

Language: JavaScript
Paradigm: multi-paradigm (object-oriented, functional, event-driven)
Use cases: web development and browser scripting, server-side development with Node.js, mobile app development with frameworks like React Native

Maintenant que vous disposez de données structurées, vous pouvez les transmettre directement à d'autres fonctions, les stocker dans des bases de données ou les afficher dans votre interface utilisateur sans aucune manipulation de texte. Pour les processus d'analyse de données, des outils tels que Pandas AI peuvent exploiter directement ces résultats structurés afin de générer des informations pertinentes.

Ajouter la sécurité des types avec Pydantic

L'analyse JSON détecte les erreurs de syntaxe, mais les types de données incorrects ou les champs manquants constituent des problèmes distincts. Les modèles Pydantic résolvent ce problème en validant votre structure de données et en détectant les problèmes avant qu'ils ne perturbent votre application :

from pydantic import BaseModel
import json

class ProgrammingLanguage(BaseModel):
   name: str
   paradigm: str
   use_cases: list[str]

messages = [{"role": "user", "content": "Describe CSS briefly. Return as JSON with fields: name, paradigm, use_cases (array of 3 items)"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse and validate with Pydantic
data = json.loads(response.choices[0].message.content)
language = ProgrammingLanguage(**data)

print(f"Validated data: {language.name} - {language.paradigm}")
print(f"Use cases: {language.use_cases}")

Validated data: CSS (Cascading Style Sheets) - Declarative, rule-based stylesheet language for describing the presentation of structured documents.
Use cases: ['Styling layout, colors, and typography of web pages', 'Responsive design across devices and viewports', 'Animations, transitions, and visual effects']

Pydantic vérifie automatiquement que name et paradigm sont des chaînes de caractères, et que use_cases est une liste de chaînes de caractères. Si l'IA renvoie des types incorrects ou omet un champ obligatoire, vous obtiendrez une erreur claire au lieu de bugs mystérieux par la suite.

Gestion des erreurs JSON

L'analyse JSON peut échouer si l'IA renvoie un texte JSON mal formé ou non JSON. Ajouter une gestion de base des erreurs :

import json

messages = [{"role": "user", "content": "Summarize machine learning in 1 sentence. Return as JSON with topic and summary fields"}]

try:
   response = litellm.completion(
       model="anthropic/claude-sonnet-4-20250514",
       messages=messages,
       response_format={"type": "json_object"}
   )
  
   data = json.loads(response.choices[0].message.content)
   print(f"Topic: {data['topic']}")
   print(f"Summary: {data['summary']}")
  
except json.JSONDecodeError:
   print("Invalid JSON returned")
except Exception as e:
   print(f"Request failed: {e}")

Topic: machine learning
Summary: Machine learning is a subset of artificial intelligence that allows computers to learn and make predictions or decisions from data without being explicitly programmed for each specific task.

Les sorties structurées remplacent l'analyse syntaxique complexe du texte par des structures de données claires. Vous pouvez associer le mode JSON à des solutions de repli, tout comme pour les complétions classiques.

Les sorties structurées vous fournissent des données claires et prévisibles qui ne perturberont pas votre logique d'analyse. Cependant, un autre problème se pose lorsque l'on passe du prototype à la production : les factures. Chaque appel API a un coût, et ces coûts peuvent s'avérer surprenants.

Cursus des coûts

Voici ce qui se produit : Votre prototype fonctionne parfaitement lors des tests avec 50 appels API par jour. Vous dépensez environ 2 dollars par semaine. Tout semble en ordre. Vous lancez la production et obtenez 500 utilisateurs. Vous effectuez désormais 5 000 appels API par jour. Votre facture mensuelle passe de 8 $ à 800 $.

Sans suivi des coûts, vous n'aviez aucun avertissement. Il est difficile de déterminer quelles fonctionnalités sont les plus coûteuses, quels modèles sont les plus onéreux ou comment établir un budget pour la croissance. Vous constatez l'augmentation de la facture quelques semaines plus tard, lorsque vous recevez le relevé de votre carte de crédit.

LiteLLM assure le suivi précis de vos dépenses auprès de tous les fournisseurs.

Comprendre l'utilisation des jetons

Chaque réponse de l'IA comprend des informations détaillées sur l'utilisation qui indiquent précisément ce qui vous est facturé :

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Explain what a REST API is in two sentences"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

print(f"Response: {response.choices[0].message.content}")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")

Response: A REST API is a web service that follows the Representational State Transfer architectural style, exposing resources identified by URLs and manipulated with HTTP methods like GET, POST, PUT, and DELETE. It uses stateless client-server communication, cacheability, and uniform representations (often JSON) to support scalable, decoupled interactions.
Prompt tokens: 15
Completion tokens: 201
Total tokens: 216

Les jetons d'entrée constituent votre invite, tandis que les jetons de sortie représentent la réponse de l'IA. Les différents fournisseurs appliquent des tarifs différents pour chaque type.

Calcul automatique des coûts

Le nombre brut de jetons ne vous indique pas le montant en dollars. LiteLLM calcule le coût réel pour vous :

# Get the cost for a completed response
cost = litellm.completion_cost(completion_response=response)
print(f"Total cost: ${cost:.4f}")
Total cost: $0.0020

La base de données tarifaire de LiteLLM convertit les jetons en dollars en fonction de votre modèle.

Calculs manuels des coûts

Il arrive parfois que vous souhaitiez estimer les coûts avant de passer un appel ou calculer les coûts pour un texte que vous avez déjà :

# Calculate cost without making an API call
prompt_text = "Explain machine learning"
completion_text = "Machine learning is a method of data analysis that automates analytical model building."

estimated_cost = litellm.completion_cost(
   model="anthropic/claude-sonnet-4-20250514",
   prompt=prompt_text,
   completion=completion_text
)

print(f"Estimated cost: ${estimated_cost:.4f}")

Estimated cost: $0.0002

Ceci est utile pour établir un budget et comparer les modèles.

Cursus de plusieurs appels API

Pour les applications qui effectuent de nombreux appels API, il est possible de suivre les coûts cumulés :

total_cost = 0.0

conversation = [
   "What is Python?",
   "How do you install Python packages?",
   "What are virtual environments?"
]

for i, question in enumerate(conversation):
   response = litellm.completion(
       model="gpt-5",
       messages=[{"role": "user", "content": question}]
   )
  
   call_cost = litellm.completion_cost(completion_response=response)
   total_cost += call_cost
  
   print(f"Call {i+1}: ${call_cost:.4f}")

print(f"Total cost: ${total_cost:.4f}")

Call 1: $0.0057
Call 2: $0.0134
Call 3: $0.0102
Total cost: $0.0292

Le suivi des coûts vous aide à prendre des décisions éclairées quant aux modèles à utiliser et à éviter les factures imprévues. Veuillez examiner le coût exact de chaque appel API et comparer les fournisseurs.

Conclusion

Vous disposez désormais des outils nécessaires pour créer des applications d'IA sans dépendre d'un fournisseur particulier. Vous avez appris les appels API de base, les repli automatiques, les réponses en streaming, les sorties structurées et le suivi des coûts.

Cela vous offre la possibilité de sélectionner les modèles les plus adaptés à chaque tâche. Changez facilement de fournisseur, configurez des solutions de secours automatiques et suivez vos coûts. Lorsque de meilleurs modèles apparaissent, vous pouvez les adopter sans avoir à réécrire le code.