LiteLLM AI Gateway

Déployer LiteLLM en tant que proxy passerelle IA pour plus de 100 LLMs sur les GPU Clore.ai

LiteLLM est une passerelle IA open-source qui fournit une API unifiée compatible OpenAI pour plus de 100 fournisseurs de modèles de langage — y compris OpenAI, Anthropic, Azure, Bedrock, HuggingFace et des modèles hébergés localement. Déployez-la sur CLORE.AI pour router, répartir la charge et gérer tous vos appels d'API LLM via un point de terminaison unique avec suivi des coûts intégré, limitation de débit et logique de secours.

La véritable puissance de LiteLLM apparaît à grande échelle : les équipes exécutant des piles mixtes locales+cloud peuvent remplacer les modèles à chaud sans toucher au code de l'application. Remplacez gpt-4o par mistral-7b-local dans la configuration, redémarrez — c'est fait.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Exigences serveur

Paramètre	Minimum	Recommandé
RAM	4 Go	8 Go+
VRAM	N/D (proxy uniquement)	N/D
Disque	10 Go	20 Go+
GPU	Non requis	Optionnel (pour les modèles locaux)

LiteLLM lui-même est un proxy basé sur CPU et ne nécessite pas de GPU. Cependant, le déployer sur un serveur GPU CLORE.AI a du sens si vous souhaitez exécuter des modèles locaux (via Ollama, TGI, vLLM) aux côtés de LiteLLM en tant que passerelle unifiée sur la même machine.

Déploiement rapide sur CLORE.AI

Image Docker : ghcr.io/berriai/litellm:main-latest

Ports : 22/tcp, 4000/http

Variables d’environnement :

Variable	Exemple	Description
OPENAI_API_KEY	sk-xxx...	Clé API OpenAI
ANTHROPIC_API_KEY	sk-ant-xxx...	Clé API Anthropic
AZURE_API_KEY	xxx...	Clé Azure OpenAI
LITELLM_MASTER_KEY	sk-my-master-key	Clé d'authentification maître pour le proxy
DATABASE_URL	postgresql://...	PostgreSQL pour le suivi des coûts
STORE_MODEL_IN_DB	True	Persister la config du modèle dans la BDD

Configuration étape par étape

1. Louez un serveur sur CLORE.AI

LiteLLM fonctionne très bien même sur des serveurs CPU uniquement. Allez sur CLORE.AI Marketplace et filtrez pour :

• Serveurs CPU au prix le plus bas pour une configuration purement proxy

• Serveurs GPU (RTX 3090+) si vous souhaitez exécuter également des modèles locaux

2. SSH sur votre serveur

ssh -p <PORT> root@<SERVER_IP>

3. Créez un fichier de configuration

LiteLLM utilise un fichier de configuration YAML pour définir les modèles :

mkdir -p /root/litellm
cat > /root/litellm/config.yaml << 'EOF'
model_list:
  # Modèles OpenAI
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

  - model_name: gpt-4o-mini
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"

  # Modèles Anthropic
  - model_name: claude-3-5-sonnet
    litellm_params:
      model: anthropic/claude-3-5-sonnet-20241022
      api_key: "os.environ/ANTHROPIC_API_KEY"

  # Modèle local via TGI (sur le même serveur, port 8080)
  - model_name: mistral-7b-local
    litellm_params:
      model: openai/mistralai/Mistral-7B-Instruct-v0.3
      api_base: "http://localhost:8080/v1"
      api_key: "none"

  # Load balancer : router vers plusieurs endpoints
  - model_name: fast-model
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"
    model_info:
      mode: chat

litellm_settings:
  drop_params: True
  set_verbose: False
  num_retries: 3
  request_timeout: 60

general_settings:
  master_key: "sk-my-secret-master-key"  # Changez ceci !
  alerting: []
EOF

4. Lancez LiteLLM

Lancement de base :

docker run -d \
  --name litellm \
  --network host \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

Avec PostgreSQL pour le suivi des coûts :

D'abord, lancez un conteneur PostgreSQL :

docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=litellm_pass \
  -e POSTGRES_DB=litellm \
  -p 5432:5432 \
  postgres:15

# Puis lancez LiteLLM avec BDD
docker run -d \
  --name litellm \
  -p 4000:4000 \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  -e DATABASE_URL="postgresql://postgres:litellm_pass@localhost:5432/litellm" \
  --network host \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

Utilisation de Docker Compose (recommandé) :

cat > /root/litellm/docker-compose.yml << 'EOF'
version: "3.8"
services:
  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000"
    volumes:
      - ./config.yaml:/app/config.yaml
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - LITELLM_MASTER_KEY=sk-my-secret-master-key
      - DATABASE_URL=postgresql://postgres:litellm_pass@db:5432/litellm
    command: --config /app/config.yaml --port 4000 --host 0.0.0.0
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: litellm_pass
      POSTGRES_DB: litellm
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
EOF

cd /root/litellm && docker compose up -d

5. Vérifiez le serveur

# Vérifier la santé
curl http://localhost:4000/health

# Lister les modèles disponibles
curl http://localhost:4000/v1/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

6. Accès via le proxy HTTP de CLORE.AI

Votre URL http_pub CLORE.AI pour le port 4000 :

https://<order-id>-4000.clore.ai/v1

Utilisez ceci comme votre api_base dans n'importe quel client compatible OpenAI.

---

Exemples d’utilisation

Exemple 1 : Appel API direct via le proxy

curl http://localhost:4000/v1/chat/completions \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role": "user", "content": "Quelle est la capitale de l'Allemagne ?"}
    ]
  }'

Exemple 2 : SDK Python OpenAI avec le proxy LiteLLM

from openai import OpenAI

# Changez juste base_url et api_key — tout le reste est identique
client = OpenAI(
    base_url="http://localhost:4000/v1",
    api_key="sk-my-secret-master-key",
)

# Utilisez n'importe quel modèle de votre config
response = client.chat.completions.create(
    model="gpt-4o-mini",  # ou "claude-3-5-sonnet", "mistral-7b-local"
    messages=[{"role": "user", "content": "Résumez les avantages du calcul GPU."}],
)
print(response.choices[0].message.content)

# Changez de modèle sans modifier le code
response2 = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role": "user", "content": "Même question, modèle différent."}],
)
print(response2.choices[0].message.content)

Exemple 3 : SDK Python LiteLLM (Direct)

import litellm

# Utiliser directement sans proxy
response = litellm.completion(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Bonjour !"}],
    api_key="votre-cle-openai",
)

# Ou router via votre proxy
response = litellm.completion(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "Bonjour !"}],
    api_base="http://localhost:4000",
    api_key="sk-my-secret-master-key",
)

Exemple 4 : Configuration de secours (fallback)

Configurez des basculements automatiques entre modèles :

# Dans config.yaml
model_list:
  - model_name: smart-fallback
    litellm_params:
      model: gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

router_settings:
  routing_strategy: least-busy
  model_group_alias:
    "gpt-4-fallback":
      - "gpt-4o"
      - "claude-3-5-sonnet"
      - "mistral-7b-local"
  num_retries: 3
  fallbacks:
    - gpt-4o:
        - claude-3-5-sonnet
        - mistral-7b-local

Exemple 5 : Tableau de bord de suivi des coûts

Après avoir activé PostgreSQL, accédez aux analyses des dépenses :

# Obtenir les dépenses par utilisateur
curl http://localhost:4000/global/spend/users \
  -H "Authorization: Bearer sk-my-secret-master-key"

# Obtenir les dépenses par modèle
curl http://localhost:4000/global/spend/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

# Générer un rapport de dépenses
curl "http://localhost:4000/global/spend?start_date=2024-01-01&end_date=2024-12-31" \
  -H "Authorization: Bearer sk-my-secret-master-key"

---

Configuration

Clés virtuelles (clés API par utilisateur)

Créez des clés séparées avec limites de débit et budgets :

# Créer une clé avec budget
curl http://localhost:4000/key/generate \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "models": ["gpt-4o-mini", "claude-3-5-sonnet"],
    "duration": "30d",
    "max_budget": 10.0,
    "metadata": {"user_id": "user_123"}
  }'

Répartition de charge

model_list:
  # Round-robin entre plusieurs clés API OpenAI
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-1
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-2

router_settings:
  routing_strategy: least-busy  # ou : simple-shuffle, latency-based-routing

Mise en cache

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379
    ttl: 3600  # 1 heure

Limitation de débit

general_settings:
  default_team_settings:
    tpm_limit: 100000   # tokens par minute
    rpm_limit: 1000     # requêtes par minute

---

Conseils de performance

1. Activez la mise en cache pour les invites répétées

Pour les applications RAG ou chatbot avec des questions courantes, la mise en cache Redis réduit les coûts de 30–70 % et fait chuter la latence P50 à <5ms sur les hits de cache :

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379

2. Utilisez des requêtes asynchrones

import asyncio
import litellm

async def batch_complete(prompts):
    tasks = [
        litellm.acompletion(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": p}],
        )
        for p in prompts
    ]
    return await asyncio.gather(*tasks)

results = asyncio.run(batch_complete(["Hello", "World", "Test"]))

3. Routage vers des modèles locaux

Routez les requêtes bon marché/simples vers des modèles locaux sur les GPU Clore.ai, les plus complexes vers GPT-4 :

model_list:
  - model_name: smart-router
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

Une configuration typique : exécuter Mistral 7B ou Llama 3 8B localement sur un RTX 3090 Clore.ai (0,10–0,15 $/h), traiter 80 % du trafic là-bas, escalader les tâches complexes vers GPT-4o. Des économies de 3–5× par rapport au cloud uniquement sont courantes.

4. Définissez des timeouts et des retries

litellm_settings:
  request_timeout: 30
  num_retries: 3
  retry_after: 5

---

Recommandations GPU Clore.ai

LiteLLM lui-même n'a pas besoin de GPU — c'est un proxy. Le choix du GPU importe uniquement lorsque vous déployez conjointement l'inférence locale.

Modèle local	GPU	Pourquoi
Mistral 7B / Llama 3 8B (bf16)	RTX 3090 24 Go	Convient confortablement, ~200 tok/s débit
Mixtral 8×7B ou Llama 3 70B (AWQ)	RTX 4090 24 Go	Bande passante mémoire plus rapide que 3090 ; prend en charge 70B AWQ 4-bit
Llama 3 70B (bf16) ou service multi-modèles	A100 80 Go	Exécutez plusieurs modèles 7–13B simultanément ; HBM2e pour faible latence

Pile recommandée pour un développeur solo : RTX 3090 + Mistral 7B + passerelle LiteLLM. Coût total sur Clore.ai : ~0,12 $/h. Gère ~50 req/min facilement, avec fallback vers GPT-4o pour les tâches complexes.

Pile équipe / production : A100 80GB, exécutez Llama 3 70B + LiteLLM + PostgreSQL. Sert 20+ utilisateurs concurrents, suivi complet des coûts, zéro dépense LLM cloud pour la plupart des requêtes.

---

Dépannage

Problème : « modèle introuvable »

Assurez-vous que le nom du modèle dans votre requête correspond exactement à ce qui se trouve dans config.yaml:

curl http://localhost:4000/v1/models -H "Authorization: Bearer sk-my-secret-master-key"

Problème : « authentification échouée »

Vérifiez votre LITELLM_MASTER_KEY variable d'environnement et utilisez-la comme token Bearer.

Problème : les changements de config ne sont pas pris en compte

Redémarrez le conteneur après les modifications de config :

docker restart litellm

Problème : latence élevée sur la première requête

LiteLLM charge les configs de modèles au démarrage. Les premières requêtes peuvent être plus lentes le temps que les connexions soient établies.

Problème : erreurs de connexion à la base de données

# Vérifiez que PostgreSQL tourne
docker logs postgres

# Vérifiez le format de la chaîne de connexion
DATABASE_URL="postgresql://user:password@host:5432/dbname"

Problème : erreurs 429 de limitation de débit de la part des fournisseurs

Configurez des basculements :

litellm_settings:
  num_retries: 5
  fallbacks:
    - gpt-4o: [claude-3-5-sonnet]

---

Recommandations GPU Clore.ai

LiteLLM est une passerelle/proxy API — il n'effectue pas d'inférence lui-même. Le choix du GPU dépend de si vous routez vers des API cloud ou des modèles locaux.

Configuration	GPU	Prix Clore.ai	Cas d’utilisation
Proxy API cloud uniquement	CPU uniquement	~0,02$/h	Routez vers OpenAI, Anthropic, Gemini — aucun GPU nécessaire
Backend local vLLM	RTX 3090 (24GB)	~0,12 $/h	Modèles auto-hébergés 7B–13B avec LiteLLM en frontend
Backend local vLLM	RTX 4090 (24GB)	~0,70 $/h	Modèles locaux 7B–34B à plus haut débit
Backend local vLLM	A100 40GB	~1,20 $/h	Modèles 70B, service local en production

Configuration la plus courante : Exécutez LiteLLM en tant que proxy unifié devant vos instances vLLM/Ollama hébergées sur Clore.ai. Cela vous offre des basculements fournisseurs, limitation de débit, suivi des coûts et routage compatible OpenAI — tout en gardant toute l'inférence locale et peu coûteuse.

Exemple de coût : Exécutez le proxy LiteLLM sur une instance CPU-only (0,02 $/h) et pointez-le vers un serveur vLLM sur RTX 3090 (0,12 $/h). Coût total ~0,14 $/h pour une API LLM auto-hébergée prête pour la production avec basculements, journalisation et limitation de débit.

---

Liens

• GitHub

• Documentation

• Docker Hub / GHCR

• Fournisseurs pris en charge

• CLORE.AI Marketplace