Formation : Création d'une application IA avec Python et l'API OpenAI

• Développeurs Python ayant suivi la formation Créer une API REST avec Python et FastAPI ou disposant d'une expérience équivalente avec FastAPI.
• Développeurs backend souhaitant intégrer des fonctionnalités IA (chatbot, analyse de texte, génération de contenu) dans leurs applications existantes.
• Freelances et développeurs en agence cherchant à enrichir leurs projets avec des appels à l'API OpenAI ou Anthropic.
• Profils techniques ayant déjà utilisé ChatGPT en mode "chat" et souhaitant passer à une intégration API réelle dans du code Python.

• Comprendre le fonctionnement d'un LLM : tokens, contexte, température, rôles system/user/assistant
• Maîtriser les techniques de prompting essentielles : zero-shot, few-shot, chain-of-thought, instructions de format
• Consommer l'API OpenAI en Python avec gestion des erreurs, retry et streaming
• Structurer les sorties du modèle en JSON fiable grâce au function calling et au mode JSON
• Implémenter une conversation multi-tours avec gestion de l'historique et du contexte
• Intégrer un LLM dans une API FastAPI existante avec streaming SSE vers le frontend
• Construire un outil d'analyse de texte (classification, résumé, extraction d'entités) utilisable en production
• Estimer, surveiller et optimiser les coûts d'appels à l'API OpenAI

• Bonne maîtrise de Python : fonctions, dictionnaires, classes, gestion des exceptions, appels HTTP avec httpx ou requests.
• Avoir déjà créé au moins un endpoint FastAPI avec Pydantic : les formations Python : POO et traitement de données et Créer une API REST avec Python et FastAPI sont recommandées, ou une expérience équivalente.
• Notions de base sur les formats JSON et les variables d'environnement.
• Aucune connaissance en machine learning, en mathématiques ou en deep learning requise.

• Qu'est-ce qu'un LLM : prédiction du token suivant, pas de "compréhension"
• La notion de contexte (context window) : taille, limites, ce que le modèle "voit"
• Les tokens : définition, comptage avec tiktoken, impact sur la facturation
• Température et top-p : contrôler la créativité vs le déterminisme
• Les modèles OpenAI disponibles : GPT-4o, GPT-4o-mini, o1 ( quand utiliser lequel )
• Les hallucinations : pourquoi elles se produisent et comment les limiter

• Créer sa clé API OpenAI, stocker dans .env, charger avec python-dotenv
• Installer et configurer le SDK officiel openai
• Structure d'un appel client.chat.completions.create() : modèle, messages, paramètres
• Lire et parser la réponse : choices[0].message.content, usage, finish_reason
• Gérer les erreurs API : RateLimitError, AuthenticationError, APIConnectionError
• Retry automatique avec backoff exponentiel : tenacity ou retry natif du SDK

• Le trio system / user / assistant : rôles et responsabilités
• Écrire un bon system prompt : persona, contraintes, format de sortie, ton
• L'ordre des instructions : ce qui est lu en premier vs en dernier
• Délimiteurs et structure : balises XML, triple backticks, numérotation
• Séparer les prompts du code : fichiers .txt, f-strings, variables d'environnement

• Zero-shot : formuler une instruction claire sans exemple
• Few-shot prompting : guider le modèle avec des exemples entrée/sortie bien construits
• Construire de bons exemples : diversité, cas limites, cohérence de format
• Chain-of-thought (CoT) : demander au modèle de "réfléchir à voix haute" avant de conclure
• Zero-shot CoT et son efficacité sur les tâches de raisonnement

• Classification de texte : sentiment, intention, catégorie
• Résumé : longueur contrainte, format bullet, résumé exécutif
• Extraction d'entités : noms, dates, montants, références
• Transformation de contenu : reformulation, traduction, correction
• Génération de code : style, commentaires, gestion des cas limites

• Pourquoi les LLMs produisent parfois du JSON invalide ou incomplet
• Instructions de format dans le prompt : schéma explicite, exemples annotés, contraintes négatives
• Le mode JSON d'OpenAI : response_format={ "type": "json_object" }
• Valider et parser la réponse : json.loads, gestion des exceptions, retry ciblé
• Pydantic pour valider la structure reçue : modèles, champs obligatoires, types

• Le function calling OpenAI : principe, paramètre tools, JSON Schema
• Différence entre appel de fonction et exécution : le LLM décide, Python exécute
• Déclarer un outil, intercepter tool_calls, retourner le résultat au modèle
• Forcer l'appel d'un outil avec tool_choice : utiliser le function calling comme extracteur de données

• Comment fonctionne la mémoire d'un LLM : il n'y en a pas (tout est dans messages[])
• Construire l'historique tour par tour : ajouter user et assistant à chaque échange
• Limites de la context window : détecter l'approche de la limite avec tiktoken
• Stratégies de troncature : supprimer les anciens tours, conserver le system prompt, résumer
• Résumé glissant : résumer l'historique ancien et l'injecter dans le system prompt

• Enrichir le system prompt à la volée : données utilisateur, catalogue produit, date/heure
• Templating de prompts : f-strings, Jinja2 pour les templates complexes
• Séparer les prompts du code : fichiers .j2, constantes de configuration
• Versionner ses prompts comme du code source

• Pourquoi streamer : UX, latence perçue, affichage progressif
• Activer le streaming : stream=True, itérer sur les ChatCompletionChunk
• Reconstituer la réponse complète depuis les deltas de tokens
• Détecter finish_reason et gérer les erreurs mid-stream

• Les Server-Sent Events (SSE) : protocole, format data: ...\n\n, connexion persistante
• Implémenter StreamingResponse dans FastAPI avec un générateur async
• Chaîner le stream OpenAI vers le stream SSE sans bufferiser la réponse complète
• Valider les entrées utilisateur avec Pydantic avant d'appeler le LLM
• Gérer le CORS pour une consommation depuis un frontend JavaScript
• Sécurité : ne jamais exposer la clé OpenAI côté client, architectures correctes

• Consommer un stream SSE en JavaScript avec fetch + ReadableStream
• Afficher les tokens au fur et à mesure dans le DOM
• Indicateur de chargement, bouton d'annulation avec AbortController

• Les tâches NLP couvables par un LLM : classification, résumé, extraction, scoring, comparaison
• Pipeline batch vs pipeline temps-réel : architectures et compromis
• Traitement parallèle : envoyer plusieurs appels en même temps avec asyncio.gather
• Utiliser l'API Batch OpenAI pour les workloads volumineux à moitié prix

• Exposer plusieurs tâches d'analyse : POST /analyze/sentiment, /summarize, /extract
• Mutualiser la logique de prompting dans des fonctions réutilisables
• Cache des réponses : éviter de rappeler le LLM pour des entrées identiques
• Logging des appels : stocker prompt, réponse, modèle, tokens consommés, durée

• Comprendre la facturation OpenAI : input tokens vs output tokens, prix par modèle
• Calculer le coût d'un cas d'usage avant de développer : outil de simulation avec tiktoken
• Choisir le bon modèle selon la tâche : GPT-4o-mini suffit souvent, GPT-4o quand nécessaire
• Réduire les coûts : condenser les prompts, limiter max_tokens, utiliser le Prompt Caching
• L'API Batch OpenAI : 50% moins cher pour les traitements non temps-réel

• Rate limits OpenAI : TPM, RPM, comment les monitorer et s'y adapter
• Retry avec backoff exponentiel : tenacity, délais progressifs, nombre max d'essais
• Timeouts et annulation : ne pas laisser une requête bloquée indéfiniment
• Évaluer la qualité des sorties : construire un jeu de tests, automatiser les évaluations
• Monitoring en production : logger latence, coût par appel, taux d'erreur

• Choisir son sujet de projet parmi la liste proposée ou valider un sujet personnel
• Concevoir l'architecture : endpoints, prompts, gestion de l'historique, format de sortie
• Identifier les techniques à mobiliser : streaming, function calling, batch, cache
• Estimer le coût par appel et le coût mensuel projeté

• Cahier des charges : construire une fonctionnalité IA concrète au choix (chatbot de support, analyseur de contrat, générateur de tests unitaires depuis du code, résumeur de tickets, assistant de rédaction avec ton personnalisé)
• Fonctionnalités attendues : system prompt structuré et versionné, au moins une technique avancée (streaming, function calling ou batch), au moins un endpoint FastAPI avec validation Pydantic, estimation du coût par appel
• Étape 1 : conception du prompt et choix du modèle
• Étape 2 : implémentation du backend FastAPI
• Étape 3 : interface minimale (HTML/JS ou CLI) pour démontrer le fonctionnement
• Étape 4 : présentation (10 min) et revue collective (choix de prompting, gestion du contexte, coût)
• Retour formateur individualisé sur les choix d'architecture et de prompting

• Écrire des prompts efficaces et robustes adaptés à des tâches métier réelles
• Consommer l'API OpenAI en Python avec gestion des erreurs, retry et streaming
• Structurer les sorties LLM en JSON Pydantic valide via le function calling
• Implémenter une conversation multi-tours avec gestion de l'historique
• Intégrer un LLM dans une API FastAPI avec streaming SSE vers le frontend
• Estimer, surveiller et optimiser les coûts d'appels à l'API OpenAI

• En cours de formation : exercices de prompting corrigés et comparés à chaque module
• En fin de formation : réalisation d'une application LLM de bout en bout avec présentation
• Questionnaire d'auto-évaluation des acquis en fin de parcours

• Prompts structurés avec system prompt explicite, rôles correctement définis et format de sortie spécifié
• Sorties JSON valides parsées sans erreur via le function calling ou le mode JSON d'OpenAI
• Historique de conversation correctement maintenu avec stratégie de troncature opérationnelle
• Endpoint FastAPI fonctionnel avec streaming SSE, validation Pydantic et gestion des erreurs API
• Traitement batch asynchrone opérationnel avec asyncio.gather sur plusieurs requêtes simultanées
• Estimation du coût par appel correcte et stratégie d'optimisation argumentée

Cette formation a été créée en 2026. Les indicateurs de résultats (taux de satisfaction, taux d’atteinte des objectifs, taux d’assiduité) seront publiés sur cette page à l’issue des premières sessions réalisées.

• Support de cours numérique mis à disposition
• Scripts Python annotés avec exercices et corrections par module
• Environnement : VS Code + Python 3.12+ + crédits API OpenAI fournis pour les exercices
• Pour le distanciel : visioconférence, partage d'écran, chat en direct

• Feuilles d'émargement signées par demi-journée (présentiel) ou émargement numérique (distanciel)
• Traçabilité des activités pédagogiques réalisées
• Attestation d'assiduité délivrée en fin de formation
• Suivi individuel via la vérification du dépôt GitHub de chaque apprenant en fin de parcours