Optimisation bout-en-bout : du prompt au réseau

L’optimisation est un système, pas un paramètre

Réduire la latence et les coûts d’une application LLM ne se limite pas à choisir un modèle plus rapide. C’est une chaîne d’optimisations qui va du prompt jusqu’à la configuration réseau. Cette leçon vous guide à travers chaque levier.

Optimiser le prompt

Réduire la taille du prompt

Chaque token en entrée coûte du temps et de l’argent. Quelques techniques concrètes :

# ❌ Prompt verbeux
prompt_long = """
Vous êtes un assistant expert en analyse financière. Vous devez toujours
répondre de manière professionnelle et structurée. Vous devez utiliser
des données chiffrées quand c'est possible. Vous devez éviter le jargon
inutile. Vous devez être concis mais complet.
Analysez le rapport trimestriel suivant : ...
"""

# ✅ Prompt optimisé (même résultat, moins de tokens)
prompt_court = """Rôle : analyste financier senior.
Contraintes : structuré, chiffré, concis.
Tâche : analysez ce rapport trimestriel : ..."""

Choisir le bon modèle par tâche

Tous les appels ne nécessitent pas le même modèle :

• Classification / extraction : gpt-5.3 — rapide, économique
• Raisonnement complexe : o4-mini — bon ratio qualité/coût
• Tâches critiques : o3-pro — meilleure qualité, plus lent
• Gros volume : gpt-5.3 via Batch API — -50 % du prix

import openai

client = openai.OpenAI()

def routeur_modele(tache: str, complexite: str) -> str:
    """Sélectionne le modèle optimal selon la tâche."""
    if complexite == "faible":
        return "gpt-5.3"
    elif tache in ("raisonnement", "mathematiques", "code"):
        return "o4-mini"
    elif complexite == "critique":
        return "o3-pro"
    return "gpt-5.3"

def appel_optimise(prompt: str, tache: str, complexite: str) -> str:
    modele = routeur_modele(tache, complexite)
    response = client.responses.create(
        model=modele,
        input=prompt,
    )
    return response.output_text

Optimiser les paramètres API

Limiter les tokens de sortie

Spécifiez toujours max_output_tokens pour éviter les réponses trop longues :

response = client.responses.create(
    model="gpt-5.3",
    input="Résumez ce texte en une phrase.",
    max_output_tokens=100,  # Limite stricte
    temperature=0.0,         # Déterministe = plus rapide
)

Température et top_p

• temperature=0 : réponses déterministes, légèrement plus rapides
• top_p=0.1 : réduit l’espace de recherche, accélère la génération

Optimiser le réseau

Localisation du serveur

Placez votre serveur applicatif dans la même région que l’endpoint API :

• API OpenAI : principalement hébergée aux États-Unis (Est)
• Gain potentiel : 50-150 ms de latence réseau

Connexions persistantes

Réutilisez les connexions HTTP pour éviter le handshake TLS à chaque requête :

import httpx

# Client avec pool de connexions persistantes
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optimiser le post-traitement

Traitez la réponse au fil du streaming plutôt qu’après réception complète :

async def traitement_progressif(prompt: str):
    """Traite chaque chunk dès sa réception."""
    stream = client.responses.create(
        model="gpt-5.3",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Traitement par phrase complète
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Points clés à retenir

• Optimisez le prompt d’abord : moins de tokens = moins de latence et de coût
• Routez vers le bon modèle selon la complexité de la tâche
• Limitez max_output_tokens et utilisez temperature=0 quand c’est possible
• Réutilisez les connexions HTTP et traitez les réponses en streaming