Tutoriel complet sur la configuration de LiteLLM avec un service proxy API tiers : 5 étapes pour intégrer APIYI

Comment faire en sorte que LiteLLM orchestre simultanément des grands modèles de langage comme OpenAI, Claude, Gemini ou DeepSeek, sans être bloqué par des problèmes de comptes étrangers, de réseau ou de paiement ? La réponse consiste à connecter LiteLLM à un service proxy API tiers compatible avec OpenAI. Dans cet article, nous allons prendre LiteLLM + APIYI apiyi.com comme exemple pour vous guider pas à pas dans la configuration.

Valeur ajoutée : En lisant cet article, vous maîtriserez les 3 méthodes principales pour configurer un service proxy API tiers dans LiteLLM (SDK, fichier YAML de proxy, variables d'environnement) et vous pourrez finaliser l'intégration d'APIYI en moins de 5 minutes.

Points clés de la configuration de LiteLLM avec un service proxy API

LiteLLM est une passerelle / SDK LLM open source dont l'objectif est d'invoquer plus de 100 grands modèles de langage en utilisant le format compatible OpenAI. Il prend nativement en charge n'importe quel point de terminaison "compatible OpenAI" ; il suffit de pointer api_base vers le service proxy et de remplacer api_key par la clé fournie par le service. APIYI apiyi.com est un service proxy standard compatible OpenAI, les deux sont donc parfaitement adaptés.

Détails sur la configuration de LiteLLM avec un service proxy tiers

La documentation officielle de LiteLLM est claire : il suffit d'ajouter le préfixe openai/ au nom du modèle et de spécifier api_base pour que LiteLLM utilise le client OpenAI pour accéder à votre point de terminaison. Cela signifie que peu importe que le service proxy soit connecté à GPT-5, Claude Opus 4.6, Gemini 3 Pro ou DeepSeek, pour LiteLLM, il s'agit toujours d'un "point de terminaison OpenAI".

L'URL de base (base_url) d'APIYI apiyi.com est https://api.apiyi.com/v1. Elle respecte les spécifications standard /v1/chat/completions, /v1/embeddings et /v1/images/generations, ce qui la rend parfaitement compatible avec LiteLLM, sans aucun correctif nécessaire.

Démarrage rapide avec LiteLLM et un service proxy API tiers

Prérequis

Avant de commencer, assurez-vous d'avoir :

1. Clé API APIYI : Après votre inscription sur apiyi.com, créez une nouvelle clé dans la console (nous vous suggérons de la nommer litellm-prod).
2. base_url : https://api.apiyi.com/v1 (attention, le /v1 à la fin est obligatoire).
3. Environnement Python : Python 3.9+.
4. Installation des dépendances : pip install litellm.

Exemple minimaliste : Configuration intégrée au SDK

La méthode la plus rapide consiste à transmettre directement api_key et api_base dans votre code :

import litellm

response = litellm.completion(
    model="openai/gpt-5",                              # Clé : préfixe openai/
    api_key="VOTRE_CLE_APIYI",
    api_base="https://api.apiyi.com/v1",               # URL du service proxy API APIYI
    messages=[
        {"role": "user", "content": "Présente LiteLLM en une phrase"}
    ],
)

print(response.choices[0].message.content)

💡 Conseil : Une fois que vous avez obtenu des crédits de test via la console APIYI (apiyi.com), vous pouvez remplacer gpt-5 par des noms de modèles comme claude-opus-4-6 ou gemini-3-pro sans modifier le reste de votre code — c'est tout l'intérêt du protocole compatible OpenAI.

import os
import litellm
from litellm import completion

# Il est recommandé de gérer les clés via des variables d'environnement
os.environ["OPENAI_API_KEY"] = "VOTRE_CLE_APIYI"
os.environ["OPENAI_API_BASE"] = "https://api.apiyi.com/v1"

litellm.set_verbose = False  # Mettre à True pour le débogage

def chat_with_apiyi(model: str, prompt: str, stream: bool = False):
    """Appeler n'importe quel modèle compatible OpenAI via LiteLLM + APIYI"""
    try:
        response = completion(
            model=f"openai/{model}",
            messages=[{"role": "user", "content": prompt}],
            stream=stream,
            temperature=0.7,
            max_tokens=1024,
        )
        if stream:
            for chunk in response:
                delta = chunk.choices[0].delta.content or ""
                print(delta, end="", flush=True)
            print()
        else:
            return response.choices[0].message.content
    except Exception as e:
        print(f"Échec de l'invocation : {e}")
        return None

if __name__ == "__main__":
    # Non-streaming
    print(chat_with_apiyi("gpt-5", "Explique ce qu'est une passerelle LLM"))
    # Streaming
    chat_with_apiyi("claude-opus-4-6", "Présente les avantages de LiteLLM en 100 mots", stream=True)

Configuration Proxy YAML : Recommandé pour la production

Si vous souhaitez exécuter LiteLLM comme un service indépendant (port 4000, partagé par l'équipe), le mode YAML est idéal. Créez un fichier litellm_config.yaml :

model_list:
  - model_name: gpt-5                       # Nom du modèle exposé
    litellm_params:
      model: openai/gpt-5                   # Préfixe openai/ pour router vers le client OpenAI
      api_base: https://api.apiyi.com/v1    # URL du service proxy APIYI
      api_key: os.environ/APIYI_KEY         # Référence à la variable d'environnement

  - model_name: claude-opus-4-6
    litellm_params:
      model: openai/claude-opus-4-6
      api_base: https://api.apiyi.com/v1
      api_key: os.environ/APIYI_KEY

  - model_name: gemini-3-pro
    litellm_params:
      model: openai/gemini-3-pro
      api_base: https://api.apiyi.com/v1
      api_key: os.environ/APIYI_KEY

litellm_settings:
  drop_params: true                          # Supprime automatiquement les paramètres non supportés
  num_retries: 2                             # Nombre de tentatives en cas d'échec

router_settings:
  fallbacks:
    - gpt-5: ["claude-opus-4-6", "gemini-3-pro"]

Lancement du proxy :

export APIYI_KEY=sk-xxxxxxxxxxxxxxxx
litellm --config ./litellm_config.yaml --port 4000

Désormais, n'importe quel SDK OpenAI peut appeler le service via http://localhost:4000 :

from openai import OpenAI

client = OpenAI(
    api_key="nimporte-quoi",                    # LiteLLM Proxy ne vérifie pas le contenu (sauf si master_key configurée)
    base_url="http://localhost:4000",
)

resp = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": "Bonjour via le proxy LiteLLM"}]
)
print(resp.choices[0].message.content)

🎯 Conseil de production : Nous recommandons d'ajouter une couche master_key devant le proxy LiteLLM et de connecter tous les modèles sous-jacents à APIYI. Ainsi, votre application ne voit que des "noms de modèles sémantiques" comme gpt-5 ou claude-opus-4-6, tandis que les canaux, la facturation et les limites de débit sont gérés par le duo APIYI + LiteLLM.

Mode variables d'environnement : Le plus simple pour les scripts

Pour les scripts ponctuels et les outils en ligne de commande, le plus simple est d'utiliser les variables d'environnement. LiteLLM détecte automatiquement OPENAI_API_KEY et OPENAI_API_BASE :

export OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxx
export OPENAI_API_BASE=https://api.apiyi.com/v1

Toutes les invocations avec le préfixe openai/ passeront alors par APIYI :

import litellm
print(litellm.completion(
    model="openai/gpt-5",
    messages=[{"role": "user", "content": "ping"}]
).choices[0].message.content)

Comparaison des trois méthodes de configuration pour LiteLLM

Le choix de la méthode dépend de votre cas d'usage. Le tableau ci-dessous vous aide à décider.

💡 Conseil : Pour le développement personnel, les variables d'environnement suffisent. Pour les équipes et la production, nous recommandons vivement le mode Proxy YAML, car il centralise le routage, le fallback, le débit et les statistiques. Quelle que soit la méthode, la connexion à APIYI reste identique : vous n'avez qu'une seule clé API à gérer.

Pratique du routage multi-modèles avec LiteLLM + APIYI

La véritable puissance du mode Proxy de LiteLLM réside dans sa capacité à utiliser un seul fichier YAML pour mapper des « noms de modèles sémantiques » vers des « canaux réels ». Voici une configuration de routage minimale prête pour la production.

# litellm_config.yaml - Exemple de routage en production
model_list:
  # Modèles d'inférence principaux
  - model_name: smart
    litellm_params:
      model: openai/gpt-5
      api_base: https://api.apiyi.com/v1
      api_key: os.environ/APIYI_KEY
      timeout: 60

  - model_name: smart
    litellm_params:
      model: openai/claude-opus-4-6
      api_base: https://api.apiyi.com/v1
      api_key: os.environ/APIYI_KEY
      timeout: 60

  # Modèles rapides et économiques
  - model_name: fast
    litellm_params:
      model: openai/gpt-5-mini
      api_base: https://api.apiyi.com/v1
      api_key: os.environ/APIYI_KEY

  # Vision / Multimodal
  - model_name: vision
    litellm_params:
      model: openai/gemini-3-pro
      api_base: https://api.apiyi.com/v1
      api_key: os.environ/APIYI_KEY

  # Embedding
  - model_name: embed
    litellm_params:
      model: openai/text-embedding-3-large
      api_base: https://api.apiyi.com/v1
      api_key: os.environ/APIYI_KEY

litellm_settings:
  drop_params: true
  num_retries: 2
  request_timeout: 60

router_settings:
  routing_strategy: simple-shuffle           # Rotation entre modèles de même nom
  fallbacks:
    - smart: ["fast"]                        # Repli vers "fast" en cas d'échec de "smart"

general_settings:
  master_key: sk-litellm-master-xxxx         # La clé que le client doit fournir

La couche applicative ne voit que quatre noms sémantiques : smart, fast, vision et embed. Lorsque GPT-5 est limité, LiteLLM bascule automatiquement vers Claude Opus 4.6 (car ils sont tous deux enregistrés sous smart), puis se replie sur fast en cas de nouvel échec. Tout le trafic sous-jacent passe par le service proxy API APIYI (apiyi.com) pour une facturation et une surveillance unifiées, isolant parfaitement la couche application de la couche canal.

Questions fréquentes sur la configuration de LiteLLM avec un service proxy API

curl http://localhost:4000/v1/chat/completions \
  -H "Authorization: Bearer sk-litellm-master-xxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "smart",
    "messages": [{"role": "user", "content": "ping"}]
  }'

Résumé

Configurer un service proxy API tiers avec LiteLLM se résume essentiellement à trois étapes :

1. Alignement du protocole : Ajoutez le préfixe openai/ au modèle pour indiquer à LiteLLM d'utiliser le protocole client OpenAI.
2. Alignement du point d'entrée : Faites pointer api_base vers le chemin racine du service proxy suivi de /v1, par exemple https://api.apiyi.com/v1.
3. Alignement des identifiants : Transmettez la clé API fournie par le service proxy via api_key ou une variable d'environnement.

Une fois ces trois étapes terminées, toutes les fonctionnalités de LiteLLM (routage multi-modèles, basculement, limitation de débit, facturation, journalisation) peuvent être superposées de manière transparente sur un service proxy stable.

🚀 Conseil pratique : Si vous mettez en place une passerelle LLM unifiée pour votre équipe, nous recommandons l'architecture à trois niveaux suivante : « Application → LiteLLM Proxy → APIYI apiyi.com ». LiteLLM gère le routage et le basculement, tandis qu'APIYI assure l'accès aux modèles sous-jacents, la stabilité et la facturation à l'usage. Vous n'avez qu'à gérer un fichier YAML et une clé. Inscrivez-vous sur apiyi.com pour obtenir un crédit de test et effectuez votre première invocation en moins de 5 minutes.

Auteur : Équipe APIYI — Spécialisée dans l'accès stable aux principaux grands modèles de langage pour les développeurs. Visitez apiyi.com pour en savoir plus.

Références

1. Documentation officielle de LiteLLM – Points de terminaison compatibles OpenAI

   • Lien : docs.litellm.ai/docs/providers/openai_compatible
   • Description : Exemples officiels pour le SDK et le fichier YAML du Proxy.

2. Vue d'ensemble de la configuration du Proxy LiteLLM

   • Lien : docs.litellm.ai/docs/proxy/configs
   • Description : Champs complets pour model_list, router_settings et fallbacks.

3. Dépôt GitHub de LiteLLM

   • Lien : github.com/BerriAI/litellm
   • Description : Code source, problèmes (issues) et dernières versions.

4. daily_stock_analysis – LLM_CONFIG_GUIDE

   • Lien : github.com/ZhuLinsen/daily_stock_analysis/blob/main/docs/LLM_CONFIG_GUIDE.md
   • Description : Référence pratique pour les trois modes de configuration et le multi-canal.

5. Documentation officielle d'APIYI

   • Lien : apiyi.com
   • Description : Liste des modèles pris en charge, base_url et gestion des clés API.