LiteLLM : Unifier l'univers des LLM pour un développement fluide

June 04, 2025

Projets Open Source Pratiques

Description du projet

LiteLLM est un SDK Python et un serveur proxy (passerelle LLM) conçu pour simplifier les interactions avec plus de 100 API de grands modèles linguistiques (LLM). Il unifie divers fournisseurs de LLM (par exemple, Bedrock, Azure, OpenAI, VertexAI, Cohere, Anthropic, Sagemaker, HuggingFace, Replicate, Groq) sous un format cohérent, rappelant celui d'OpenAI.

LiteLLM vise à gérer des complexités telles que : - La traduction des entrées vers les points de terminaison de complétion, d'embedding et de génération d'images spécifiques à chaque fournisseur. - L'assurance de formats de sortie cohérents entre les différents LLM. - L'implémentation de logiques de relance et de repli sur plusieurs déploiements (par exemple, Azure/OpenAI) via sa fonction Router. - La possibilité d'appliquer des budgets et des limites de débit par projet, clé API et modèle via le serveur proxy LiteLLM.

Instructions d'utilisation

Pour utiliser LiteLLM, installez-le via pip :

pip install litellm

Complétion de chat de base

from litellm import completion
import os

# Définissez les variables d'environnement pour les clés API
os.environ["OPENAI_API_KEY"] = "votre-cle-openai"
os.environ["ANTHROPIC_API_KEY"] = "votre-cle-anthropic"

messages = [{ "content": "Bonjour, comment allez-vous ?","role": "user"}]

# Appel OpenAI
response = completion(model="openai/gpt-4o", messages=messages)

# Appel Anthropic
response = completion(model="anthropic/claude-3-sonnet-20240229", messages=messages)
print(response)

Appels asynchrones

from litellm import acompletion
import asyncio

async def test_get_response():
    user_message = "Bonjour, comment allez-vous ?"
    messages = [{"content": user_message, "role": "user"}]
    response = await acompletion(model="openai/gpt-4o", messages=messages)
    return response

response = asyncio.run(test_get_response())
print(response)

Flux de réponses (Streaming Responses)

from litellm import completion

response = completion(model="openai/gpt-4o", messages=messages, stream=True)
for part in response:
    print(part.choices[0].delta.content or "")

Journalisation et observabilité

LiteLLM prend en charge divers outils de journalisation et d'observabilité (Lunary, MLflow, Langfuse, DynamoDB, S3, Helicone, Promptlayer, Traceloop, Athina, Slack) via des callbacks.

from litellm import completion
import os
import litellm

# Définissez les variables d'environnement pour les outils de journalisation et les clés API
os.environ["LUNARY_PUBLIC_KEY"] = "votre-cle-publique-lunary"
os.environ["HELICONE_API_KEY"] = "votre-cle-helicone"
os.environ["LANGFUSE_PUBLIC_KEY"] = "" # Utilisez les vraies clés
os.environ["LANGFUSE_SECRET_KEY"] = "" # Utilisez les vraies clés
os.environ["ATHINA_API_KEY"] = "votre-cle-api-athina"
os.environ["OPENAI_API_KEY"] = "votre-cle-openai"

# Définissez les callbacks
litellm.success_callback = ["lunary", "mlflow", "langfuse", "athina", "helicone"]

response = completion(model="openai/gpt-4o", messages=[{"role": "user", "content": "Salut 👋 - je suis openai"}])

Serveur proxy LiteLLM

Pour exécuter le serveur proxy LiteLLM :

Installez-le avec les dépendances du proxy :
```
pip install 'litellm[proxy]'
```

Démarrez le proxy :

litellm --model huggingface/bigcode/starcoder
# INFO: Proxy en cours d'exécution sur http://0.0.0.0:4000

Effectuez des requêtes vers le proxy en utilisant un SDK OpenAI :

import openai # openai v1.0.0+
client = openai.OpenAI(api_key="nimporte-quoi",base_url="http://0.0.0.0:4000") # définissez le proxy comme base_url
response = client.chat.completions.create(model="gpt-3.5-turbo", messages = [
    {
        "role": "user",
        "content": "ceci est une requête de test, écris un court poème"
    }
])
print(response)

Fonctionnalités clés

Interface API unifiée : Connectez-vous à plus de 100 LLM en utilisant un seul format d'API de type OpenAI.
Prise en charge des fournisseurs : Prend en charge les principaux fournisseurs de LLM, notamment Bedrock, Azure, OpenAI, VertexAI, Cohere, Anthropic, Sagemaker, HuggingFace, Replicate, Groq, et bien d'autres.
Sortie cohérente : Toutes les réponses textuelles sont toujours disponibles à ['choices'][0]['message']['content'].
Routeur (Logique de relance/repli) : Gère automatiquement les mécanismes de relance et de repli entre plusieurs déploiements de LLM.
Prise en charge du streaming : Prend en charge les réponses en continu pour tous les modèles intégrés.
Opérations asynchrones : Fournit des appels d'API asynchrones pour une performance améliorée.
Observabilité : S'intègre à divers outils de journalisation et d'observabilité (par exemple, Lunary, MLflow, Langfuse, Helicone) via des callbacks.
Serveur proxy LiteLLM (Passerelle LLM) :
- Suivi des coûts : Surveillez les dépenses sur différents projets.
- Équilibrage de charge : Répartissez les requêtes entre plusieurs déploiements de LLM.
- Limitation de débit : Appliquez des limites de débit par projet, clé API et modèle.
- Gestion des clés : Se connecte à une base de données PostgreSQL pour créer et gérer des clés proxy avec un contrôle granulaire sur les modèles, les durées et les métadonnées.
- Interface Web (UI) : Offre une interface utilisateur (/ui) pour gérer le serveur proxy, y compris la définition des budgets et des limites de débit.
Fonctionnalités d'entreprise : Offre une sécurité améliorée, une gestion des utilisateurs et un support professionnel pour les utilisateurs commerciaux, y compris des intégrations personnalisées et des SLA.

Public cible

Développeurs et ingénieurs : Recherchant une interface unifiée pour interagir avec divers fournisseurs de LLM, simplifiant le code et la gestion.
Équipes IA/ML : Cherchant des solutions pour gérer l'accès aux LLM, surveiller l'utilisation, contrôler les coûts et implémenter des stratégies robustes de relance/repli.
Organisations développant des applications basées sur les LLM : Ayant besoin de fonctionnalités telles que la limitation de débit, la gestion budgétaire et l'observabilité pour leur infrastructure IA.
Chercheurs : Qui ont besoin d'expérimenter efficacement avec plusieurs modèles et fournisseurs de LLM.

Liens du projet

Répertoire GitHub : https://github.com/BerriAI/litellm
Documentation : https://docs.litellm.ai/docs/
Package PyPI : https://pypi.org/project/litellm/

Scénarios d'application

Construction d'applications multi-LLM : Passez facilement d'un LLM à un autre ou combinez-les (par exemple, GPT-4 pour l'écriture créative, Claude pour la synthèse) sans modifier la logique d'application principale.
Optimisation des coûts et budgétisation : Implémentez des quotas stricts et des budgets souples par utilisateur, projet ou clé API en utilisant le proxy, évitant ainsi les dépenses inattendues.
Assurer une haute disponibilité et fiabilité : Utilisez le routeur pour un repli automatique vers un fournisseur ou un déploiement de LLM alternatif en cas de défaillance ou de dépassement des limites de débit.
Tests A/B de modèles LLM : Acheminez le trafic vers différents modèles de manière transparente pour comparer les performances et les coûts en production.
Passerelle LLM centralisée : Établissez un point d'entrée unique pour tous les appels LLM au sein d'une organisation, simplifiant la sécurité, la journalisation et le contrôle d'accès.
Surveillance et observabilité : Obtenez des informations sur l'utilisation, les performances et les coûts du LLM en l'intégrant à divers outils d'observabilité.
Développement d'agents/orchestration LLM : Fournissez un backend robuste et flexible pour les agents qui doivent interagir avec diverses capacités LLM (chat, embeddings, génération d'images).