> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/modeles-de-langage/litellm.md).

# 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é.

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

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

{% hint style="info" %}
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.
{% 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`             | 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](https://clore.ai/marketplace) 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

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

  # É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 :**

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

Commencez par lancer un conteneur PostgreSQL :

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

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

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

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

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

```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"}
  }'
```

### Équilibrage 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   # 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 :

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

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

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

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

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

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

```yaml
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](https://clore.ai/bare-metal) | Modèles 70B, service local de production                 |

{% hint style="info" %}
**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.
{% 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)
* [la place de marché CLORE.AI](https://clore.ai/marketplace)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.