LiteLLM - Passerelle d'appel d'API de grands modèles de langage unifiée

Aperçu du projet

LiteLLM est un SDK Python open source et un serveur proxy (passerelle LLM) capable d'appeler plus de 100 API de grands modèles de langage au format OpenAI, y compris les principaux fournisseurs tels que Bedrock, Azure, OpenAI, VertexAI, Cohere, Anthropic, Sagemaker, HuggingFace, Replicate, Groq, etc.

Adresse GitHub : https://github.com/BerriAI/litellm

Fonctionnalités principales

1. Format d'API unifié

• Normalisation du format d'entrée : Conversion des entrées de tous les fournisseurs en un format unifié
• Cohérence du format de sortie : La réponse textuelle est toujours disponible dans ['choices'][0]['message']['content']
• Prise en charge de plusieurs points de terminaison : Prise en charge des points de terminaison completion, embedding et image_generation

2. Garantie de haute disponibilité

• Logique de nouvelle tentative/repli : Prise en charge des nouvelles tentatives et des replis automatiques entre plusieurs déploiements (par exemple, Azure/OpenAI)
• Fonction de routage : Routage intelligent vers le meilleur modèle disponible
• Équilibrage de charge : Répartition de la charge de requête entre plusieurs déploiements

3. Contrôle des coûts et des autorisations

• Gestion du budget : Définition de limites budgétaires par projet, clé API, modèle
• Limitation du débit : Prévention de l'utilisation excessive des appels d'API
• Suivi de l'utilisation : Statistiques d'appel détaillées et analyse des coûts

Principales caractéristiques

Exemples d'utilisation du SDK Python

Appel de base

from litellm import completion
import os


os.environ["OPENAI_API_KEY"] = "your-openai-key"
os.environ["ANTHROPIC_API_KEY"] = "your-anthropic-key"

messages = [{"content": "Hello, how are you?", "role": "user"}]

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

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

Prise en charge des appels asynchrones

from litellm import acompletion
import asyncio

async def test_get_response():
    user_message = "Hello, how are you?"
    messages = [{"content": user_message, "role": "user"}]
    response = await acompletion(model="openai/gpt-4o", messages=messages)
    return response

response = asyncio.run(test_get_response())

Réponse en flux continu

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 "")

Fonctionnalités du serveur proxy

Démarrage rapide

pip install 'litellm[proxy]'
litellm --model huggingface/bigcode/starcoder
# INFO: Proxy running on http://0.0.0.0:4000

Appel client

import openai

client = openai.OpenAI(
    api_key="anything",
    base_url="http://0.0.0.0:4000"
)

response = client.chat.completions.create(
    model="gpt-3.5-turbo", 
    messages=[{
        "role": "user",
        "content": "this is a test request, write a short poem"
    }]
)

Fournisseurs pris en charge

LiteLLM prend en charge plus de 30 principaux fournisseurs de LLM, notamment :

Fournisseurs de services cloud majeurs

• OpenAI - Modèles de la série GPT
• Azure - Service Azure OpenAI
• AWS - Bedrock et SageMaker
• Google - Vertex AI, PaLM, Gemini
• Anthropic - Modèles de la série Claude

Plateformes open source et professionnelles

• HuggingFace - Hébergement de modèles open source
• Replicate - Service d'API de modèles
• Together AI - Inférence de modèles open source
• Groq - Puce d'inférence à haute vitesse
• Ollama - Exécution de modèles locaux

Plateformes de fonctionnalités spéciales

• Cohere - NLP de niveau entreprise
• AI21 - Modèle Jurassic
• Perplexity - Génération améliorée par la recherche
• DeepInfra - Inférence haute performance

Observabilité et journalisation

LiteLLM prend en charge nativement plusieurs plateformes de surveillance et de journalisation :

import litellm
import os


os.environ["LUNARY_PUBLIC_KEY"] = "your-lunary-public-key"
os.environ["HELICONE_API_KEY"] = "your-helicone-auth-key"
os.environ["LANGFUSE_PUBLIC_KEY"] = "your-langfuse-public-key"


litellm.success_callback = [
    "lunary", "mlflow", "langfuse", 
    "athina", "helicone"
]


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

Plateformes de surveillance prises en charge :

• Lunary - Surveillance des applications LLM
• MLflow - Suivi des expériences d'apprentissage automatique
• Langfuse - Suivi des applications LLM
• Helicone - Surveillance des appels d'API
• Athina - Évaluation des applications d'IA

Fonctionnalités d'entreprise

Système de gestion des clés

curl 'http://0.0.0.0:4000/key/generate' \
  --header 'Authorization: Bearer sk-1234' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "models": ["gpt-3.5-turbo", "gpt-4", "claude-2"], 
    "duration": "20m",
    "metadata": {
      "user": "user@company.com", 
      "team": "core-infra"
    }
  }'

Déploiement Docker

git clone https://github.com/BerriAI/litellm
cd litellm


echo 'LITELLM_MASTER_KEY="sk-1234"' > .env
echo 'LITELLM_SALT_KEY="your-salt-key"' > .env


docker-compose up

Interface de gestion Web

• Accédez à /ui pour obtenir une interface de gestion visuelle
• Définissez des budgets et des limites de débit pour plusieurs projets
• Surveillez l'utilisation de l'API en temps réel
• Gestion des utilisateurs et des équipes

Spécifications techniques

Configuration système requise

• Version Python : Nécessite Python 3.7+
• Dépendances requises :
  • openai>=1.0.0 (v1.0.0+ requis)
  • pydantic>=2.0.0 (v1.40.14+ requis)

Normes de qualité du code

• Style de code : Suivez le guide de style Python de Google
• Outils de formatage : Utilisez Black et isort
• Vérification du type : MyPy et Pyright
• Vérification du code : Ruff pour la vérification lint

Garantie de stabilité

• Version stable : Utilisez l'image Docker avec l'étiquette -stable
• Tests de charge : Effectuez des tests de charge de 12 heures avant la publication
• Intégration continue : Processus CI/CD complet

Support commercial

Fonctionnalités de la version Entreprise

• Fonctionnalités de sécurité avancées : Intégration de l'authentification unique (SSO)
• Support professionnel : Support dédié Discord et Slack
• Intégration personnalisée : Intégration personnalisée du fournisseur LLM
• Garantie SLA : Accord de niveau de service
• Priorité des fonctionnalités : Développement prioritaire des fonctionnalités demandées par l'entreprise

Support communautaire

• GitHub Issues : Demandes de fonctionnalités et signalement de problèmes
• Communauté Discord : Communication et support en temps réel
• Documentation complète : Documentation API et tutoriels détaillés

Cas d'utilisation

1. Déploiement LLM multi-cloud

• Évitez le verrouillage du fournisseur
• Réalisez des appels de modèles multiplateformes
• Réduisez les coûts de migration

2. Optimisation des coûts

• Routage intelligent vers le modèle disponible le moins cher
• Contrôle du budget et surveillance de l'utilisation
• Optimisation des appels d'API par lots

3. Architecture à haute disponibilité

• Basculement automatique
• Équilibrage de charge
• Prise en charge du déploiement multi-régions

4. Amélioration de l'efficacité du développement

• Interface API unifiée
• Simplification du changement de modèle
• Prise en charge riche du SDK

Installation et démarrage rapide

Installation de base

pip install litellm

Installation du serveur proxy

pip install 'litellm[proxy]'

Configuration de l'environnement de développement

git clone https://github.com/BerriAI/litellm
cd litellm


python -m venv .venv
source .venv/bin/activate


pip install -e ".[all]"


uvicorn litellm.proxy.proxy_server:app --host localhost --port 4000 --reload

Résumé

LiteLLM a été adopté par des entreprises renommées telles que Rocket Money, Samsara, Lemonade et Adobe. En fournissant une interface API unifiée, de puissantes fonctionnalités de routage et des fonctionnalités de gestion de niveau entreprise, il simplifie considérablement la complexité de la gestion des environnements multi-LLM, ce qui en fait un choix idéal pour le développement d'applications d'IA modernes.