Passerelle IA LiteLLM

Déployez LiteLLM comme proxy de passerelle IA pour plus de 100 LLM sur les GPU Clore.ai

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

La vraie puissance de LiteLLM se révèle à grande échelle : les équipes qui exploitent des piles mixtes local+cloud peuvent changer de modèle à chaud sans toucher au code de l’application. Remplacez gpt-4o avec mistral-7b-local dans la configuration, redémarrez — terminé.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Exigences du serveur

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

LiteLLM lui-même est un proxy basé sur le CPU et n’a pas besoin de GPU. Cependant, le déployer sur un serveur GPU CLORE.AI a du sens lorsque vous souhaitez exécuter des modèles locaux (via Ollama, TGI, vLLM) aux côtés de LiteLLM comme 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	Conserver la configuration du modèle dans la base de données

Configuration étape par étape

1. Louez un serveur sur CLORE.AI

LiteLLM fonctionne très bien même sur des serveurs sans GPU. Allez sur la place de marché CLORE.AI et filtrez pour :

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

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

2. Connectez-vous en SSH à 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"

  # Équilibreur de charge : route vers plusieurs points de terminaison
  - model_name: mistral-7b-local
    litellm_params:
      model: openai/mistralai/Mistral-7B-Instruct-v0.3
      api_base: "http://localhost:8080/v1"
      api_key: "none"

  # Équilibreur de charge : route vers plusieurs points de terminaison
  - 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 :

Commencez par lancer un conteneur PostgreSQL :

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

# Ensuite, lancez LiteLLM avec la base de données
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

Avec 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 l'état
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édez via le proxy HTTP CLORE.AI

Votre URL CLORE.AI http_pub 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 simplement 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 configuration
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 sur GPU."}],
)
print(response.choices[0].message.content)

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

Exemple 3 : SDK Python LiteLLM (direct)

import litellm

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

# Ou routez 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 repli

Configurez des replis automatiques entre les 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 des 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 des limites de débit et des 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"}
  }'

Équilibrage 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   # jetons 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 les chatbots avec des questions fréquentes, la mise en cache Redis réduit les coûts de 30 à 70 % et fait tomber la latence P50 à <5 ms lors des hits du 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 de modèles locaux

Routez les requêtes simples/peu coûteuses vers des modèles locaux sur les GPU de Clore.ai, et 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écutez Mistral 7B ou Llama 3 8B localement sur une RTX 3090 Clore.ai ($0.07–0.21/h), traitez-y 80 % du trafic, et escaladez les tâches complexes vers GPT-4o. Des économies de 3 à 5 fois par rapport à une solution uniquement cloud sont courantes.

4. Définissez des délais d’attente et des tentatives

litellm_settings:
  request_timeout: 30
  num_retries: 3
  retry_after: 5

---

Recommandations GPU Clore.ai

LiteLLM lui-même n’a besoin d’aucun GPU — c’est un proxy. Le choix du GPU ne compte que si vous déployez aussi l’inférence locale à ses côtés.

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

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

Pile équipe / production : A100 80 Go, exécutez Llama 3 70B + LiteLLM + PostgreSQL. Sert plus de 20 utilisateurs simultanés, suivi complet des coûts, zéro dépense cloud LLM 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 : « échec de l’authentification »

Vérifiez votre LITELLM_MASTER_KEY variable d’environnement et utilisez-la comme jeton Bearer.

Problème : les modifications de configuration ne sont pas reflétées

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

docker restart litellm

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

LiteLLM charge les configurations des modèles au démarrage. Les premières requêtes peuvent être plus lentes pendant l’établissement des connexions.

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

# Vérifiez que PostgreSQL est en cours d’exécution
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 limite de débit provenant des fournisseurs

Configurez des replis :

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

---

Recommandations GPU Clore.ai

LiteLLM est une passerelle/proxy API — il ne fait pas l’inférence lui-même. Le choix du GPU dépend de savoir 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	Route vers OpenAI, Anthropic, Gemini — aucun GPU requis
Backend local vLLM	RTX 3090 (24 Go)	0,07–0,21 $/h	Modèles auto-hébergés 7B–13B avec LiteLLM comme frontend
Backend local vLLM	RTX 4090 (24 Go)	0,14–0,42 $/h	Modèles locaux 7B–34B à haut débit
Backend local vLLM	A100 40 Go	bare metal	Modèles 70B, service local de production

Configuration la plus courante : Faites fonctionner LiteLLM comme proxy unifié devant vos instances vLLM/Ollama hébergées sur Clore.ai. Cela vous apporte des replis de fournisseurs, la limitation de débit, le suivi des coûts et un routage compatible OpenAI — tout en conservant toute l’inférence en local et à bas coût.

Exemple de coût : Faites fonctionner le proxy LiteLLM sur une instance uniquement CPU (0,07–0,21 $/h) et pointez-le vers un serveur vLLM sur RTX 3090 (0,07–0,21 $/h). Coût total de 0,07–0,21 $/h pour une API LLM auto-hébergée, prête pour la production, avec replis, journalisation et limitation de débit.

---

Liens

• GitHub

• Documentation

• Docker Hub / GHCR

• Fournisseurs pris en charge

• la place de marché CLORE.AI