Prise en main de LiteLLM Proxy Server

Mise à jour : 10/09/2025

Dans le précédent guide sur LiteLLM, nous avons exploré comment utiliser le SDK LiteLLM pour interagir avec divers modèles de langage. Maintenant, nous allons approfondir un aspect important pour les entreprises : la gestion centralisée et sécurisée des accès aux modèles de langage via LiteLLM Proxy Server.

LiteLLM Proxy Server répond au besoin d’industrialiser l’accès aux LLM en entreprise : une passerelle unique, OpenAI-compatible, qui masque l’hétérogénéité des fournisseurs, réduit le shadow IT, et sépare la logique « modèles » du code applicatif pour faciliter le multi-sourcing.

Fonctionnalités de LiteLLM Proxy Server

LiteLLM Proxy Server propose deux éditions principales : Open Source (gratuite) et Enterprise (payante à partir de 250$/mois). Voici un comparatif détaillé des fonctionnalités disponibles :

Version Open Source

Fonctionnalités principales :

Accès unifié à 100+ modèles LLM : OpenAI, Anthropic, Azure, AWS Bedrock, Hugging Face, etc.
Compatibilité OpenAI : Tous les endpoints OpenAI (/chat/completions, /embeddings, /batches)
Gestion des clés virtuelles : Création et gestion d’API keys pour utilisateurs/équipes
Suivi des coûts de base : Tracking des dépenses par modèle, clé, utilisateur et équipe
Budgets et rate limiting : Définition de budgets et limites de requêtes par utilisateur/équipe
Interface d’administration web : UI pour gérer utilisateurs, équipes et configurations
Logging basique : Intégration avec outils d’observabilité (Langfuse, Langsmith)
Fallbacks et load balancing : Routage intelligent et stratégies de basculement
Cache Redis : Amélioration des performances et réduction des coûts
Alertes webhook : Notifications Slack/Discord/Teams/Email pour budgets et incidents

Version Enterprise (250$/mois)

Fonctionnalités supplémentaires exclusives :

Authentification avancée :

SSO/OIDC/JWT Authentication : Intégration avec Azure AD, Keycloak, etc.
Génération automatique de tokens temporaires : Réduction de la gestion manuelle des clés
Group-based access : Gestion d’accès basée sur les groupes d’utilisateurs

Monitoring et observabilité :

Métriques Prometheus : Monitoring avancé avec alertes et dashboards
Support avec SLA : Assistance technique avec garanties de niveau de service
Alerting Pagerduty : Intégration avec systèmes d’alerte enterprise

Gestion organisationnelle :

Gestion d’organisations : Structure hiérarchique équipes → organisations
Admin délégués : Attribution de droits d’administration par équipe/organisation
Modèles privés par équipe : Restriction d’accès à certains modèles par équipe
Model Access Groups : Groupes de modèles avec permissions granulaires

Fonctionnalités avancées :

Guardrails enterprise : Filtres de contenu et politiques de sécurité par équipe
Logging enterprise : Datadog, S3, GCS, Azure Data Lake avec rétention configurable
Virtual Key Rotation : Rotation automatique des clés pour la sécurité
Temporary Budget Increase : Augmentations temporaires de budgets
Budget/Rate Limit Tiers : Niveaux de budgets et limites hiérarchiques

Tableau comparatif des fonctionnalités

La version open source offre déjà un ensemble robuste de fonctionnalités pour la plupart des cas d’usage, tandis que l’enterprise répond aux besoins spécifiques des grandes organisations avec des exigences de sécurité et de governance strictes.

Fonctionnalité	Open Source	Enterprise
Accès 100+ LLMs	✅	✅
Interface Web	✅	✅
Budgets/Rate Limiting	✅	✅
Suivi des coûts	✅	✅
Clés virtuelles	✅	✅
Webhooks alertes	✅	✅
SSO/OIDC/JWT	❌	✅
Métriques Prometheus	❌	✅
Support SLA	❌	✅
Gestion organisations	❌	✅
Admin délégués	❌	✅
Modèles privés équipes	❌	✅
Guardrails avancés	❌	✅
Logging enterprise	❌	✅
Rotation automatique clés	❌	✅

Architecture et concepts fondamentaux de LiteLLM

LiteLLM Proxy Server fonctionne comme un reverse proxy intelligent qui traduit les requêtes au format OpenAI vers les API natives de chaque fournisseur de modèles. Cette architecture modulaire offre une abstraction complète des spécificités techniques de chaque provider.

Le proxy intercepte les requêtes HTTP entrantes formatées selon les spécifications OpenAI et les transforme dynamiquement pour correspondre aux paramètres attendus par le fournisseur cible. Cette transformation bidirectionnelle préserve la compatibilité avec l’écosystème OpenAI tout en exploitant la diversité des modèles disponibles.

L’architecture de LiteLLM repose sur plusieurs composants interconnectés qui garantissent la fiabilité et les performances :

Router intelligent : Distribue les requêtes selon les stratégies définies
Gestionnaire de connexions : Maintient les pools de connexions optimisés
Cache distribuée : Améliore les temps de réponse et réduit les coûts
Module d’authentification : Sécurise l’accès via keys virtuelles
Système de monitoring : Collecte métriques et logs pour l’observabilité

Prérequis techniques et environnement de développement

Avant d’initier le déploiement de LiteLLM Proxy Server, il convient de vérifier que votre environnement technique dispose des composants requis et des permissions nécessaires pour un fonctionnement optimal.

LiteLLM Proxy Server est développé en Python et s’appuie sur plusieurs bibliothèques open-source. Une bonne maîtrise de Python, des concepts de réseau et des API REST est recommandée pour suivre ce guide.

Configuration système minimale

Le proxy LiteLLM nécessite un environnement Python 3.8 ou supérieur avec un accès réseau stable vers les API des fournisseurs de modèles. Pour les déploiements de production, recommandez au minimum 2 CPU cores et 4 GB de RAM, extensibles selon la charge de trafic prévue.

# Vérification de la version Python
python3 --version

# Installation des dépendances système sur Ubuntu/Debian
sudo apt update
sudo apt install python3-pip python3-venv curl wget

# Sur CentOS/RHEL
sudo dnf install python3-pip python3-venv curl wget

Préparation de l’environnement virtuel

L’isolation des dépendances Python garantit la stabilité et la reproductibilité des déploiements. Créez un environnement virtuel dédié pour éviter les conflits de versions avec d’autres applications.

# Création du répertoire de projet
mkdir -p litellm-proxy/{config,logs,scripts,data}
cd litellm-proxy

# Création de l'environnement virtuel
python3 -m venv litellm-env

# Activation de l'environnement
source litellm-env/bin/activate
# Mise à jour de pip vers la dernière version
pip install --upgrade pip setuptools wheel

Gestion des clés d’authentification

Organisez la gestion sécurisée des clés API des différents fournisseurs avant l’installation. Utilisez des variables d’environnement ou un gestionnaire de secrets pour éviter l’exposition des credentials dans la configuration.

# Création d'un fichier de configuration des variables d'environnement
cat > .env << EOF
export OPENAI_API_KEY="sk-your-openai-key"
export ANTHROPIC_API_KEY="sk-ant-your-anthropic-key"
EOF

source .env

Vérification des connectivités réseau

Testez la connectivité vers les API des principaux fournisseurs pour identifier d’éventuels blocages au niveau firewall ou proxy d’entreprise.

# Test de connectivité OpenAI
curl -I https://api.openai.com/v1/models

# Test de connectivité Anthropic
curl -I https://api.anthropic.com/v1/models

Installation et configuration initiale du proxy

L’installation de LiteLLM Proxy Server peut s’effectuer via plusieurs méthodes selon votre contexte de déploiement. La méthode pip reste la plus directe pour les environnements de développement, tandis que Docker offre une approche standardisée pour la production.

Installation via pip et premiers tests

LiteLLM propose plusieurs packages selon vos besoins spécifiques. Le package standard convient pour la plupart des cas d’usage, tandis que l’option [proxy] inclut les dépendances pour le mode serveur.

# Installation du package complet avec support proxy
pip install litellm[proxy]

# Vérification de l'installation
litellm --version
# Exemple de sortie attendue
LiteLLM: Current Version = 1.76.3

Démarrage rapide et premier test

Une fois l’installation terminée, vous pouvez lancer immédiatement le proxy en pour valider le fonctionnement de base. Pour cela, nous allons démarrer le serveur avec un modèle spécifique et tester une requête simple.

# Démarrage avec un modèle spécifique et port personnalisé
litellm --model gpt-3.5-turbo --port 4000

# Une fois le service démarré, test de connectivité vers le proxy local dans un autre terminal
curl -X POST http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-1234" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [{"role": "user", "content": "Bonjour, LiteLLM!"}]
  }' | jq .

Vous devriez recevoir une réponse JSON contenant la complétion générée par le modèle, confirmant que le proxy fonctionne correctement.

{
  "id": "chatcmpl-CDli4FYvoVH8aeH0oOKLp8W11Yemy",
  "created": 1757397696,
  "model": "gpt-3.5-turbo-0125",
  "object": "chat.completion",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "Bonjour! Comment puis-je vous aider aujourd'hui?",
        "role": "assistant",
        "annotations": []
      },
      "provider_specific_fields": {}
    }
  ],
  "usage": {
    "completion_tokens": 9,
    "prompt_tokens": 13,
    "total_tokens": 22,
    "completion_tokens_details": {
      "accepted_prediction_tokens": 0,
      "audio_tokens": 0,
      "reasoning_tokens": 0,
      "rejected_prediction_tokens": 0
    },
    "prompt_tokens_details": {
      "audio_tokens": 0,
      "cached_tokens": 0
    }
  },
  "service_tier": "default"
}

Configuration avancée de LiteLLM Proxy Server

Pour simplifier la gestion de LiteLLM Proxy Server, il est recommandé de structurer la configuration via un fichier YAML. Cela permet de centraliser la configuration des modèles, des stratégies d’authentification, et des politiques de coûts.

Configuration de base avec plusieurs modèles

Commençons par créer une configuration YAML structurée qui intègre plusieurs fournisseurs d’IA. Créez le fichier de configuration de base :

cat > config/proxy-config.yaml << EOF
model_list:
  # Modèles OpenAI
  - model_name: gpt-4
    litellm_params:
      model: openai/gpt-4
      api_key: os.environ/OPENAI_API_KEY
      max_tokens: 4096

  - model_name: gpt-3.5-turbo
    litellm_params:
      model: openai/gpt-3.5-turbo
      api_key: os.environ/OPENAI_API_KEY
      max_tokens: 4096

# Configuration générale minimale
general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
EOF

Avant de lancer le proxy, définissons la variable d’environnement pour la clé d’administration (pensez à les ajouter dans votre .env) :

export LITELLM_MASTER_KEY=sk-$(openssl rand -hex 16)
export LITELLM_PROXY_API_KEY=${LITELLM_MASTER_KEY}

Test de la configuration de base :

# Démarrage du proxy avec la configuration
litellm --config config/proxy-config.yaml --port 4000

# Vérification des modèles disponibles
curl -X GET http://localhost:4000/v1/models \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" | jq .

Normalement, vous devriez obtenir la liste des modèles disponibles :

{
  "data": [
    {
      "id": "gpt-4",
      "object": "model",
      "created": 1677610602,
      "owned_by": "openai"
    },
    {
      "id": "gpt-3.5-turbo",
      "object": "model",
      "created": 1677610602,
      "owned_by": "openai"
    },
  ],
  "object": "list"
}

Activation de l’interface d’administration

L’interface web facilite grandement la gestion du proxy. Activons-la

commencer par installer postgreSQL pour la persistance des données.

# Installation de PostgreSQL sur Ubuntu/Debian
sudo apt update
sudo apt install postgresql postgresql-contrib

# Installation sur Centos/RHEL
sudo dnf install postgresql-server postgresql-contrib

# Démarrage du service
sudo systemctl enable --now postgresql

# Création de la base de données et du user
sudo -u postgres psql -c "CREATE USER litellm_user WITH ENCRYPTED PASSWORD 'litellm_secure_password123';"
sudo -u postgres psql -c "CREATE DATABASE litellm_db OWNER litellm_user;"
sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE litellm_db TO litellm_user;"

Ajouter ces lignes au fichier de configuration de liteLLM :

# Ajout dans config/proxy-config.yaml
general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
  database_url: os.environ/DATABASE_URL

  # 🔥 Activation de l'interface web
  ui: true
  ui_username: os.environ/UI_USERNAME
  ui_password: os.environ/UI_PASSWORD

  # Configuration des logs
  set_verbose: true
  json_logs: true

Configuration des variables d’environnement pour l’UI :

# Ajout dans .env
cat >> .env << 'EOF'
# Interface d'administration
export UI_USERNAME=admin
export UI_PASSWORD=SecureAdminPassword123!
export DATABASE_URL="postgresql://litellm_user:litellm_secure_password123@localhost:5432/litellm_db"
EOF

# Rechargement des variables
source .env

Bien sûr, remplissez avec vos propres identifiants sécurisés.

Test de l’interface :

# Redémarrage du proxy avec la nouvelle configuration
litellm --config config/proxy-config.yaml --port 4000

Maintenant testez l’accès à l’interface web d’administration : http://localhost:4000/ui ↗

LiteLLM Admin UI

Créations d’utilisateurs et gestion des clés

L’interface web permet de créer facilement des équipes, des utilisateurs, d’y associer des clés d’API, et de définir des politiques de coûts. Mais nous allons voir comment le faire avec des call d’API pour automatiser ces tâches.

D’ailleurs, j’en profite pour vous rappeler que toutes les opérations d’administration peuvent être effectuées via l’API REST. LiteLLM expose une documentation Swagger à l’adresse http://localhost:4000 ↗ pour découvrir toutes les possibilités.

Swagger

Deux possibilités s’offrent à vous :

Créer des utilisateurs simples :
Créer des équipes auxquels vous ajouterez des membres

Lorsque vous créez une équipe ou un utilisateur, une clé d’API virtuelle est automatiquement générée et affectée à cette équipe. À partir de là, vous pouvez utiliser cette clé pour faire des appels au proxy, et bénéficier des politiques de coûts et de suivi associées. Vous pouvez aussi limiter l’accès à certains modèles par équipe.

Conclusion

LiteLLM Proxy Server s’impose comme une solution incontournable pour industrialiser l’accès aux modèles de langage en entreprise. Ce guide vous a accompagné dans la découverte des fondamentaux : de l’installation basique jusqu’à la configuration d’un proxy productif avec authentification, suivi des coûts et interface d’administration.

LiteLLM évolue rapidement avec de nouvelles fonctionnalités ajoutées régulièrement. La version open source que nous avons explorée offre déjà un ensemble robuste de fonctionnalités pour la plupart des cas d’usage professionnels. Pour les organisations nécessitant des fonctionnalités avancées comme l’authentification SSO/OIDC, les métriques Prometheus ou la gestion d’organisations complexes, la version Enterprise apporte ces capacités supplémentaires.

Pour parfaire l’installation, reste plus qu’à :

configurer un service systemd pour garantir le redémarrage automatique et la résilience du proxy en cas de panne serveur.
mettre en frontale un reverse proxy comme HAProxy , Nginx ou Traefik pour gérer le SSL et la haute disponibilité.

Plus d’informations

Documentation officielle : docs.litellm.ai ↗
GitHub : github.com/BerriAI/litellm ↗
Communauté : Discord et discussions GitHub pour le support communautaire
Exemples pratiques : Repository d’exemples et configurations types