L'Atelier — Réseau francophone IA (produit, tech, business)

Gestion d'erreurs pour applications IA

Les applications IA ont des modes d'erreur uniques : hallucinations, timeouts longs, rate limits, réponses incohérentes. Une gestion gracieuse de ces erreurs est essentielle pour la confiance utilisateur.

Taxonomie des erreurs IA

Erreurs techniques

Rate limiting (429)
Timeout (génération trop longue)
Modèle indisponible (503)
Context length exceeded
Content filter triggered

Erreurs de qualité

Hallucinations (informations inventées)
Réponse hors sujet
Refus inapproprié (over-refusal)
Réponse incomplète ou tronquée

Pattern : Retry avec fallback

async function resilientLLMCall(params: LLMParams): Promise<LLMResponse> {
  const providers = [
    { name: 'primary', fn: () => callClaude(params) },
    { name: 'secondary', fn: () => callOpenAI(params) },
    { name: 'cache', fn: () => getCachedResponse(params) },
  ];

  for (const provider of providers) {
    try {
      const response = await withTimeout(provider.fn(), 30000);
      if (isQualityResponse(response)) return response;
    } catch (error) {
      logError(provider.name, error);
      continue;
    }
  }

  return gracefulFallback(params);
}

Messages d'erreur utilisateur

Rate limit

"Notre assistant est très sollicité en ce moment.
Votre demande sera traitée dans quelques secondes.
[Barre de progression avec estimation]"

Timeout

"La réponse prend plus de temps que prévu.
[Simplifier ma question] [Réessayer] [Contacter le support]"

Incertitude détectée

"Je ne suis pas certain de cette réponse.
Voici ce que j'ai trouvé, mais je vous recommande de vérifier :
[Réponse avec indicateur de confiance basse]
[Sources consultées]"

Pattern : Circuit Breaker

class LLMCircuitBreaker {
  private failures = 0;
  private lastFailure: Date | null = null;
  private threshold = 5;
  private resetTimeout = 60000; // 1 minute

  async call<T>(fn: () => Promise<T>): Promise<T> {
    if (this.isOpen()) {
      throw new CircuitOpenError('Service temporarily unavailable');
    }

    try {
      const result = await fn();
      this.reset();
      return result;
    } catch (error) {
      this.recordFailure();
      throw error;
    }
  }

  private isOpen(): boolean {
    if (this.failures >= this.threshold) {
      const elapsed = Date.now() - this.lastFailure!.getTime();
      return elapsed < this.resetTimeout;
    }
    return false;
  }
}

Gestion des hallucinations

Détection

Vérification des sources (le contenu est-il dans le contexte ?)
Score de confiance du modèle (logprobs)
Consistency check (générer 2 fois, comparer)

Communication à l'utilisateur

Ne jamais présenter une hallucination potentielle comme un fait
Toujours montrer les sources quand disponibles
Avertir quand aucune source ne supporte l'affirmation

Checklist de résilience

Timeout configuré sur chaque appel LLM (max 30s)
Retry automatique (max 3, avec backoff exponentiel)
Fallback vers un modèle plus rapide ou un cache
Circuit breaker pour éviter la cascade d'erreurs
Messages utilisateur clairs et actionnables
Logging structuré de toutes les erreurs pour le debugging

Error handling gracieux pour apps IA