# LiteLLM AI Gateway

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.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

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

{% hint style="info" %}
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.
{% endhint %}

## 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](https://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

```bash
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 :

```bash
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 :**

```bash
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 :

```bash
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é) :**

```bash
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

```bash
# 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

```bash
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

```python
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)

```python
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 :

```yaml
# 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 :

```bash
# 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 :

```bash
# 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

```yaml
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

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

### Limitation de débit

```yaml
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 :

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

### 2. Utilisez des requêtes asynchrones

```python
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 :

```yaml
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

```yaml
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`:

```bash
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 :

```bash
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

```bash
# 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 :

```yaml
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                     |

{% hint style="info" %}
**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.
{% endhint %}

***

## Liens

* [GitHub](https://github.com/BerriAI/litellm)
* [Documentation](https://docs.litellm.ai)
* [Docker Hub / GHCR](https://github.com/BerriAI/litellm/pkgs/container/litellm)
* [Fournisseurs pris en charge](https://docs.litellm.ai/docs/providers)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/litellm.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.