0Pricing
AI Engineering Academy · Leçon

Évaluation, déploiement et bilan rétrospectif

Exécutez le dispositif d’évaluation complet, notamment les métriques de recherche, les scores de qualité attribués par le LLM-évaluateur et les tests de charge, déployez-le chez un fournisseur cloud, puis rédigez un bilan rétrospectif consignant les enseignements tirés.

Évaluation, déploiement et bilan rétrospectif est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

La dernière étape : évaluer avant de déployer

Un système n’est pas prêt à être déployé tant qu’il n’a pas été évalué de bout en bout dans des conditions réelles. La phase d’évaluation finale combine toutes les techniques apprises dans ce parcours : les métriques de recherche pour vérifier que le pipeline RAG trouve les bons segments, les scores d’évaluation par LLM juge pour vérifier la qualité des réponses, les tests de charge pour vérifier les SLA de latence et l’analyse de sécurité pour vérifier le renforcement. Tout doit être validé avant le début du déploiement.

Exécuter la batterie d’évaluation complète

Exécutez la suite d’évaluation complète dans votre environnement de préproduction à l’aide d’un échantillon représentatif de requêtes semblables à celles de la production. Enregistrez toutes les métriques : taux de succès, MRR et NDCG pour la recherche ; fidélité et pertinence de la réponse pour la génération ; coût par requête ; latence p50/p95/p99. Comparez chaque métrique aux critères de réussite définis lors de la phase d’architecture. Ne déployez pas le système tant que tous les seuils minimaux stricts ne sont pas atteints.

async def final_evaluation(system_url: str, test_set_path: str) -> dict:
    test_cases = load_test_set(test_set_path)
    results = []
    for case in test_cases:
        start = time.perf_counter()
        response = await query_system(system_url, case['question'])
        latency_ms = (time.perf_counter() - start) * 1000
        judge_score = await judge(case['question'], response['answer'], case.get('reference'))
        hit = any(case['relevant_doc'] in s for s in response.get('sources', []))
        results.append({'latency_ms': latency_ms, 'score': judge_score, 'hit': hit, 'cost': response.get('cost_usd', 0)})
    return compute_final_metrics(results)

Tester la charge du système de production

Exécutez un test de charge simulant un trafic de production réaliste avant la mise en ligne. Utilisez un outil comme Locust ou k6 pour augmenter progressivement la charge jusqu’à la concurrence maximale prévue (par exemple, 50 utilisateurs simultanés) et mesurez l’évolution de la latence sous charge. Vérifiez que les disjoncteurs ne se déclenchent pas sous une charge normale, que le limiteur de débit renvoie correctement des réponses 429 lors des pics de trafic et que le taux de succès du cache sémantique reste supérieur à votre objectif. Corrigez toute régression avant de poursuivre.

# Locust load test (locustfile.py)
from locust import HttpUser, task, between
import random

QUESTIONS = [
    'What is the return policy?',
    'How do I cancel my subscription?',
    'Where are you located?',
]

class AIUser(HttpUser):
    wait_time = between(1, 3)  # realistic think time

    @task
    def query(self):
        self.client.post(
            '/query',
            json={'question': random.choice(QUESTIONS), 'tenant_id': 'load_test'},
            headers={'Authorization': 'Bearer test_token'}
        )

# Run: locust -f locustfile.py --headless -u 50 -r 5 --run-time 5m

Déployer en production

Déployez selon une stratégie de déploiement bleu-vert : démarrez la nouvelle version (verte) à côté de la version existante (bleue), exécutez des tests de bon fonctionnement sur la version verte, puis transférez progressivement le trafic de la version bleue vers la version verte. Commencez avec 5 % du trafic sur la version verte, surveillez les taux d’erreur et la latence pendant 10 minutes, puis passez à 25 %, ensuite à 50 % et enfin à 100 %. Vous pouvez ainsi revenir instantanément à la version bleue en cas de problème, sans aucune interruption de service.

# Deployment steps (pseudocode for AWS ECS or K8s):
# 1. Build and push new Docker image
#    docker build -t qa-assistant:v2.0 . && docker push ...
#
# 2. Deploy green (new) version alongside blue (current)
#    kubectl apply -f deploy/green.yaml
#
# 3. Run smoke tests against green
#    pytest tests/smoke/ --base-url https://green.internal
#
# 4. Canary traffic shift (ALB weighted routing)
#    5%  -> green (monitor 10min)
#    25% -> green (monitor 10min)
#    50% -> green (monitor 10min)
#    100% -> green
#
# 5. Decommission blue after 24h stability

Surveiller après le déploiement

Après le déploiement, surveillez activement les métriques clés pendant les deux premières heures. Surveillez : le taux d’erreur (objectif <1 %), la latence p95 (objectif <8 s), le taux de succès du cache (objectif >20 %) et le coût par requête (objectif <$0.05). Créez un canal Slack de cellule de crise réunissant tous les ingénieurs d’astreinte pour le premier déploiement. Le franchissement d’un seuil d’avertissement déclenche une investigation ; le franchissement d’un seuil critique déclenche un retour immédiat à la version bleue.

# Post-deploy monitoring dashboard queries:
# (Assuming Grafana + Prometheus)

# Error rate (last 5 min):
# rate(http_requests_total{status=~'5..'}[5m]) / rate(http_requests_total[5m])

# p95 latency (last 5 min):
# histogram_quantile(0.95, rate(query_duration_seconds_bucket[5m]))

# Cache hit rate:
# rate(cache_hits_total[5m]) / rate(queries_total[5m])

# Average cost per query:
# rate(llm_cost_usd_total[5m]) / rate(queries_total[5m])

Rédiger le bilan de l’architecture

Après une semaine de fonctionnement du système, rédigez un document de bilan qui expose ce qui a fonctionné, ce qui n’a pas fonctionné et ce que vous feriez différemment. Un bon bilan rend honnêtement compte des échecs et présente précisément les enseignements tirés. Les futurs lecteurs — y compris vous-même dans six mois — tireront profit de la compréhension du raisonnement qui a guidé les décisions prises sous la pression du temps et des obstacles imprévus rencontrés.

# RETROSPECTIVE.md structure:
#
# ## What Worked Well
# - Hybrid retrieval improved hit rate from 71% to 89%
# - Semantic cache reduced average cost by 31%
# - LangSmith tracing saved 2 days of debugging
#
# ## What Did Not Work
# - Semantic chunking was 4x slower than recursive chunking
#   with only 3% hit rate improvement -- not worth it
# - Cohere reranker had 400ms latency -- too slow for p95 target
#   Switched to BGE-reranker-v2 running locally
#
# ## What We'd Do Differently
# - Start with pgvector, not Pinecone (migration cost 3 days)
# - Add semantic cache BEFORE building the agent, not after

Documenter les guides d’intervention

Rédigez des guides d’intervention pour chaque alerte susceptible de se déclencher en production. Un guide d’intervention est une procédure détaillée, étape par étape, pour diagnostiquer et résoudre une alerte donnée. Il doit répondre aux questions suivantes : que signifie cette alerte, quelle en est la cause probable, comment la diagnostiquer et comment la corriger ? Les guides d’intervention réduisent le temps moyen de résolution (MTTR) de plusieurs heures à quelques minutes en évitant de devoir réfléchir aux étapes du diagnostic pendant un incident stressant.

# runbooks/latency.md
# ## Alert: p95 Latency > 8000ms
#
# ### Likely Causes
# 1. OpenAI API degraded (check status.openai.com)
# 2. Cohere reranker slow (check Cohere status page)
# 3. pgvector query slow (check DB CPU in CloudWatch)
# 4. Redis cache full (check Redis memory usage)
#
# ### Diagnosis
# curl https://api.openai.com/v1/models -H 'Authorization: Bearer $KEY'
# Check LangSmith traces for which step is slow
# SELECT mean(duration) FROM traces GROUP BY step
#
# ### Fixes
# - If OpenAI slow: circuit breaker should auto-failover to Claude
# - If Cohere slow: disable reranking temporarily (env SKIP_RERANK=1)
# - If DB slow: increase pgvector ef_search from 40 to 20

Mesurer l’impact métier

Après un mois en production, mesurez l’impact métier au-delà des indicateurs techniques. Pour un assistant de questions-réponses : de combien le volume de demandes adressées au support a-t-il diminué ? Quel est le taux de satisfaction des utilisateurs concernant les requêtes auxquelles l’IA a répondu ? Combien de requêtes le système a-t-il traitées alors qu’elles nécessitaient auparavant l’intervention d’agents humains du support ? Ces indicateurs métier justifient l’investissement et orientent la priorisation future entre les améliorations de la qualité et les nouvelles fonctionnalités.

# Business impact metrics (month 1):
# Technical:
# - 12,847 queries served, 11,439 (89%) answered without human
# - Avg query cost: $0.031 (within $0.05 budget)
# - System uptime: 99.94%
#
# Business:
# - Support tickets: 1,840/month -> 1,203/month (-35%)
# - Avg resolution time: 4.2h -> 23 seconds for AI-answered
# - User CSAT on AI answers: 4.1/5.0
# - Cost per resolved query: $12 (human) -> $0.031 (AI)
# - ROI: 157% in month 1 at current volumes

Planifier la prochaine itération

Un système mis en production n’est jamais terminé : il constitue une base pour une amélioration continue. Utilisez vos données d’évaluation, les retours des utilisateurs et les enseignements de la rétrospective pour planifier la prochaine itération. Donnez la priorité aux améliorations qui ont le plus fort impact sur les indicateurs les plus importants : si le taux de réussite de la recherche constitue le facteur limitant, investissez dans un meilleur découpage en segments ou dans un autre modèle d’incorporation ; si la satisfaction des utilisateurs est faible malgré une bonne recherche, investissez dans la qualité des instructions.

# Next iteration priorities (based on first month data):
NEXT_SPRINT = [
    # High impact / high confidence
    {
        'feature': 'Sentence-window retrieval',
        'expected_impact': 'Hit rate 89% -> 93%',
        'effort': 'medium',
        'evidence': '11% of failures due to answer split across chunks'
    },
    # High impact / medium confidence
    {
        'feature': 'Query decomposition for multi-hop questions',
        'expected_impact': 'Multi-hop correctness 61% -> 78%',
        'effort': 'high',
        'evidence': '23% of failures are multi-hop questions'
    },
    # Low effort quick win
    {
        'feature': 'Extend cache TTL from 1h to 24h',
        'expected_impact': 'Cache hit rate 31% -> 38%',
        'effort': 'trivial',
        'evidence': 'Same questions asked daily by different users'
    }
]

Partage des connaissances et documentation

Rédigez une documentation décrivant les principales décisions d’implémentation non évidentes du système. Il s’agit notamment de préciser pourquoi cette taille de segment a été choisie (et ce que les expériences ont montré), comment le seuil de similarité du cache sémantique a été étalonné, quels motifs d’injection le filtre détecte actuellement et lesquels lui échappent, ainsi que la manière d’ajouter de nouveaux outils à l’agent. Une bonne documentation interne réduit le temps d’intégration des nouveaux contributeurs et empêche qu’une personne qui ne connaît pas les raisons de ces choix ne les annule accidentellement.

# INTERNALS.md — key non-obvious decisions:
#
# ## Chunk Size: 800 tokens with 100 token overlap
# We tested 400, 600, 800, 1200 tokens.
# 800 tokens maximizes hit rate (89%) while keeping context
# small enough for 5 chunks to fit comfortably in 4096 token prompt.
# Larger chunks improved recall but degraded precision.
#
# ## Cache Similarity Threshold: 0.92
# Tested 0.85, 0.90, 0.92, 0.95.
# 0.92 gives 31% hit rate with <2% incorrect cache hits.
# 0.85 gives 41% hit rate but 8% incorrect hits (too aggressive).
#
# ## Reranker Top-N: 3 (from initial 10)
# More than 3 chunks causes context stuffing without quality gain.

Ce que vous avez construit

Réfléchissez au système complet que vous avez construit tout au long de ce projet de synthèse : un pipeline RAG hybride combinant une recherche dense et clairsemée avec un reclassement, un agent en flux continu avec appel de fonctions et garde-fous de sécurité, un cache sémantique réduisant les coûts de 30 %, des disjoncteurs assurant un basculement automatique, une évaluation par LLM-as-judge exécutée en continu dans l’intégration et le déploiement continus, ainsi que des protections contre l’injection d’instructions qui défendent le système contre les entrées adverses. Voilà ce qu’est l’ingénierie de l’IA en production.

# System capabilities summary:
SYSTEM_CAPABILITIES = {
    'retrieval': 'Hybrid BM25+dense with Cohere reranking, 89% hit rate',
    'generation': 'GPT-4o with Claude fallback, circuit breaker, streaming',
    'caching': 'Semantic cache (Redis+embeddings), 31% cache hit rate',
    'security': 'Injection filter (2-stage) + output scanning + tenant isolation',
    'observability': 'LangSmith traces + Prometheus metrics + PagerDuty alerts',
    'evaluation': 'Automated LLM-as-judge in CI, daily full suite, LangSmith evals',
    'reliability': '99.94% uptime, circuit breakers, graceful degradation ladder',
    'cost': '$0.031/query average, model routing saves 67% vs GPT-4o only',
}

Vérification rapide

Vérifiez votre compréhension du déploiement et de l’évaluation en production des systèmes d’IA.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que : l’évaluation finale associe les indicateurs de recherche, les scores d’évaluation par LLM-as-judge, les tests de charge et l’analyse de sécurité avant le début de tout déploiement ; le déploiement bleu-vert avec déplacement progressif du trafic permet un retour en arrière instantané sans interruption de service ; et les rétrospectives et les guides d’exploitation consignent les connaissances collectives, ce qui réduit le temps nécessaire à la résolution des incidents futurs. Félicitations, vous avez terminé le parcours Ingénierie de l’IA : LLM, RAG et agents !

Questions Fréquemment Posées

La leçon « Évaluation, déploiement et bilan rétrospectif » est-elle gratuite ?

Oui — le texte complet de « Évaluation, déploiement et bilan rétrospectif » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Évaluation, déploiement et bilan rétrospectif » ?

Exécutez le dispositif d’évaluation complet, notamment les métriques de recherche, les scores de qualité attribués par le LLM-évaluateur et les tests de charge, déployez-le chez un fournisseur cloud,… Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Évaluation, déploiement et bilan rétrospectif » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Concevoir l’architecture de production
  2. Implémenter les fonctionnalités essentielles de RAG et d’agent
  3. Renforcement : sécurité, mise en cache et fiabilité
  4. Évaluation, déploiement et bilan rétrospectif
← Retour à AI Engineering Academy