Scaling de 0 à 1M requêtes/jour

Évolution d'une infra LLM par étapes

Passer d'un prototype à 1M requêtes/jour ne se fait pas en un saut. Voici les étapes typiques et les décisions architecturales à chaque palier.

Phase 1 : Prototype (0-100 req/jour)

Architecture

App → API OpenAI/Anthropic directe

Décisions

• Utiliser les APIs managées (OpenAI, Anthropic)
• Pas d'infra GPU à gérer
• Focus sur la qualité du produit, pas l'infra
• Coût : ~$5-50/jour

Phase 2 : Validation (100-10K req/jour)

Architecture

App → API Gateway (rate limiting, auth) → Provider API
         ↓
    Cache (Redis) pour les requêtes fréquentes

Optimisations

• Semantic caching : Cacher les réponses pour des questions similaires
• Prompt optimization : Réduire les tokens (coût direct)
• Streaming : Améliorer le temps perçu
• Coût : ~$50-500/jour

import hashlib
import redis

def cached_llm_call(prompt, similarity_threshold=0.95):
    cache_key = get_semantic_hash(prompt)
    cached = redis.get(cache_key)
    if cached:
        return cached
    response = llm.generate(prompt)
    redis.setex(cache_key, 3600, response)
    return response

Phase 3 : Scale (10K-100K req/jour)

Architecture

App → Load Balancer → [vLLM instance 1 (2xA100)]
                    → [vLLM instance 2 (2xA100)]
                    → [Fallback: API provider]

Décisions

• Self-hosting pour les modèles à haut volume
• Garder l'API provider en fallback
• Modèle quantifié (INT8) pour 2x le throughput
• Auto-scaling sur la queue depth
• Coût : ~$500-5000/jour (GPUs) vs ~$2000-20000 (API pure)

Phase 4 : High scale (100K-1M req/jour)

Architecture

Clients → CDN (cache statique)
       → API Gateway → Queue (Kafka/SQS)
                     → Worker Pool → [GPU Cluster]
                                   → [Model Router]
                                   → [Fallback APIs]

Optimisations critiques

• Model routing : Petit modèle pour les requêtes simples, grand modèle pour les complexes
• Async processing : Queue pour les requêtes non-temps-réel
• Multi-region : Réduire la latence globale
• Prefix caching : Partager le KV cache pour les prompts système identiques

def route_model(request):
    complexity = estimate_complexity(request.prompt)
    if complexity < 0.3:
        return "llama-3-8b"  # Rapide et cheap
    elif complexity < 0.7:
        return "llama-3-70b"  # Bon rapport qualité/coût
    else:
        return "gpt-4o"  # Qualité maximale via API

Métriques de scaling

Leçons apprises

• Ne pas sur-architecturer trop tôt
• Le cache est votre meilleur ami (30-50% de hit rate typique)
• Le model routing divise les coûts par 3-5x
• Toujours garder un fallback API pour absorber les pics