Passer au contenu principal

​
Sélection du modèle

Choisir le bon modèle peut avoir un impact significatif sur le coût et la qualité.

​
Recommandations par tâche

TâcheModèles recommandésRaisonnement
Questions-réponses simplesgpt-4o-mini, gemini-2.5-flashRapide, économique, suffisant
Raisonnement complexeo3, claude-opus-4-5, deepseek-r1Meilleure logique et planification
Codageclaude-sonnet-4-5, gpt-4o, deepseek-v3.2Optimisé pour le code
Écriture créativeclaude-sonnet-4-5, gpt-4oMeilleure qualité de prose
Vision/Imagesgpt-4o, claude-sonnet-4-5, gemini-2.5-flashSupport natif de la vision
Contexte longgemini-2.5-pro, claude-sonnet-4-5Fenêtres de plus de 1M de tokens
Sensible au coûtgpt-4o-mini, gemini-2.5-flash, deepseek-v3.2Meilleur rapport qualité-prix

​
Niveaux de coût

$$$$ Premium: o3, claude-opus-4-5, gpt-4o
$$$  Standard: claude-sonnet-4-5, gpt-4o
$$   Budget:   gpt-4o-mini, gemini-2.5-flash
$    Economy:  deepseek-v3.2, deepseek-r1

​
Optimisation des coûts

​
1. Utiliser d’abord des modèles plus petits

def smart_query(question: str, complexity: str = "auto"):
    """Use cheaper models for simple tasks."""

    if complexity == "simple":
        model = "gpt-4o-mini"
    elif complexity == "complex":
        model = "gpt-4o"
    else:
        # Start cheap, escalate if needed
        model = "gpt-4o-mini"

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": question}]
    )
    return response

​
2. Définir max_tokens

Définissez toujours une limite max_tokens raisonnable : 
# ❌ Mauvais : Aucune limite, pourrait générer des milliers de tokens
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarize this article"}]
)

# ✅ Bon : Limiter la longueur de la réponse
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarize this article"}],
    max_tokens=500  # Limite raisonnable pour un résumé
)

​
3. Optimiser les prompts

# ❌ Prompt verbeux (plus de tokens d'entrée)
prompt = """
I would like you to please help me by analyzing the following text
and providing a comprehensive summary of the main points. Please be
thorough but also concise in your response. The text is as follows:
{text}
"""

# ✅ Prompt concis (moins de tokens)
prompt = "Summarize the key points:\n{text}"

​
4. Activer la mise en cache

Profitez de la mise en cache sémantique : 
# Pour les requêtes similaires répétées, le cache permet des économies majeures
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What is machine learning?"}],
    temperature=0  # Déterministe = meilleurs hits de cache
)

​
5. Grouper les requêtes similaires

# ❌ De nombreuses petites requêtes
for question in questions:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": question}]
    )

# ✅ Moins de requêtes plus volumineuses
combined_prompt = "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)])
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": f"Answer each question:\n{combined_prompt}"}]
)

​
Optimisation de la performance

​
1. Utiliser le streaming pour l’UX

Le streaming améliore la performance perçue : 
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a long essay"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

​
2. Choisir des modèles rapides pour une utilisation interactive

Cas d’utilisationRecommandéLatence
Interface de chatgpt-4o-mini, gemini-2.5-flash~200ms premier token
Complétion par tabulationclaude-haiku-4-5~150ms premier token
Traitement en arrière-plangpt-4o, claude-sonnet-4-5~500ms premier token

​
3. Définir des délais d’expiration (timeouts)

client = OpenAI(
    api_key="sk-your-key",
    base_url="https://api.lemondata.cc/v1",
    timeout=60.0  # Délai d'expiration de 60 secondes
)

​
Fiabilité

​
1. Implémenter des tentatives (retries)

import time
from openai import RateLimitError, APIError

def chat_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="gpt-4o",
                messages=messages
            )
        except RateLimitError:
            wait = 2 ** attempt
            print(f"Rate limited, waiting {wait}s...")
            time.sleep(wait)
        except APIError as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(1)
    raise Exception("Max retries exceeded")

​
2. Gérer les erreurs avec élégance

from openai import APIError, AuthenticationError, RateLimitError

try:
    response = client.chat.completions.create(...)
except AuthenticationError:
    # Vérifier la clé API
    notify_admin("Invalid API key")
except RateLimitError:
    # Mettre en file d'attente pour plus tard ou utiliser un secours
    add_to_queue(request)
except APIError as e:
    if e.status_code == 402:
        notify_admin("Balance low")
    elif e.status_code >= 500:
        # Erreur serveur, réessayer plus tard
        schedule_retry(request)

​
3. Utiliser des modèles de secours (fallback)

FALLBACK_CHAIN = ["gpt-4o", "claude-sonnet-4-5", "gemini-2.5-flash"]

def chat_with_fallback(messages):
    for model in FALLBACK_CHAIN:
        try:
            return client.chat.completions.create(
                model=model,
                messages=messages
            )
        except APIError:
            continue
    raise Exception("All models failed")

​
Sécurité

​
1. Protéger les clés API

# ❌ Ne jamais coder les clés en dur
client = OpenAI(api_key="sk-abc123...")

# ✅ Utiliser des variables d'environnement
import os
client = OpenAI(api_key=os.environ["LEMONDATA_API_KEY"])

​
2. Valider les entrées utilisateur

def validate_message(content: str) -> bool:
    """Validate user input before sending to API."""
    if len(content) > 100000:
        raise ValueError("Message too long")
    # Ajouter d'autres validations si nécessaire
    return True

​
3. Définir des limites pour les clés API

Créez des clés API distinctes avec des limites de dépenses pour :
  • Le développement/test
  • La production
  • Différentes applications

​
Surveillance (Monitoring)

​
1. Suivre l’utilisation

Consultez régulièrement votre tableau de bord pour :
  • L’utilisation des tokens par modèle
  • La répartition des coûts
  • Les taux de réussite du cache
  • Les taux d’erreur

​
2. Enregistrer les métriques importantes

import logging

response = client.chat.completions.create(...)

logging.info({
    "model": response.model,
    "prompt_tokens": response.usage.prompt_tokens,
    "completion_tokens": response.usage.completion_tokens,
    "total_tokens": response.usage.total_tokens,
})

​
3. Configurer des alertes

Configurez des alertes de solde bas dans votre tableau de bord pour éviter toute interruption de service.

​
Liste de contrôle

  • Utilisation du modèle approprié pour chaque tâche
  • Définition des limites max_tokens
  • Les prompts sont concis
  • Mise en cache activée lorsque c’est approprié
  • Groupement des requêtes similaires
  • Streaming pour l’UX interactive
  • Modèles rapides pour une utilisation en temps réel
  • Timeouts configurés
  • Logique de tentative (retry) implémentée
  • Gestion des erreurs en place
  • Modèles de secours configurés
  • Clés API dans les variables d’environnement
  • Validation des entrées
  • Clés distinctes pour dev/prod
  • Limites de dépenses définies