Pydantic for LLM Workflows

Ces 15 exercices de niveau intermédiaire sont conçus pour plus de pratique. Ces exercices suivent une progression logique, des bases de Pydantic à son application dans des workflows LLM complexes comme le “tool calling”. Ces exercices vous aident à améliorer vos compétences techniques à savoir utiliser Pydantic pour générer des sorties structurées à partir de LLM, en s’assurant que les réponses suivent un format spécifique que votre application peut traiter de manière fiable. Vous apprendrez également les compétences de validation de données pour gérer une grande variété de besoins de formatage et de structuration de données dans tout système logiciel. Vous construirez un système avec validation de données à chaque étape, en utilisant les modèles Pydantic pour valider tout, depuis les entrées utilisateur et les réponses LLM jusqu’à la définition des paramètres pour l’appel d’outils. Essayez de travailler chaque exercice et vous pouvez cliquer pour voir la correction et l’explication.

Exercice 1 : Création d'un Modèle de Base

Exercice

Créez un modèle Pydantic nommé Utilisateur pour représenter un utilisateur avec un id (entier), un nom (chaîne de caractères) et une date_inscription (objet datetime).

Solution

from pydantic import BaseModel
from datetime import datetime

class Utilisateur(BaseModel): id: int nom: str date_inscription: datetime # Exemple d’instanciation utilisateur_valide = Utilisateur( id=101, nom=”Alice”, date_inscription=”2023-10-27T10:00:00″ ) print(utilisateur_valide)

Explication

Exercice 2 : Gestion des Champs Optionnels et des Valeurs par Défaut

Exercice

Modifiez le modèle Utilisateur pour que le nom ait une valeur par défaut de “Anonyme” et ajoutez un champ optionnel email qui doit être une chaîne de caractères.

Solution

from pydantic import BaseModel
from datetime import datetime
from typing import Optional

class Utilisateur(BaseModel):
  id: int
  nom: str = "Anonyme"
  date_inscription: datetime
  email: Optional[str] = None

# Exemples d'instanciation
user1 = Utilisateur(id=1, date_inscription="2023-01-01")
print(user1)
# > id=1 nom='Anonyme' date_inscription=datetime.datetime(2023, 1, 1, 0, 0) email=None

user2 = Utilisateur(id=2, date_inscription="2023-01-02", email="test@example.com")
print(user2)
# > id=2 nom='Anonyme' date_inscription=datetime.datetime(2023, 1, 2, 0, 0) email='test@example.com'

Explication

Exercice 3 : Validation de Types Spécifiques (EmailStr)

Exercice

Créez un modèle Contact avec un champ nom (chaîne) et un champ adresse_email qui doit être un email valide. Tentez de l’instancier avec une adresse email invalide pour observer l’erreur.

Solution

from pydantic import BaseModel, EmailStr, ValidationError

class Contact(BaseModel):
  nom: str
  adresse_email: EmailStr

# Instanciation valide
contact_valide = Contact(nom="Bob", adresse_email="bob@example.com")
print(contact_valide)

# Tentative d'instanciation invalide
try:
Contact(nom="Charlie", adresse_email="charlie-is-not-an-email")
except ValidationError as e:
print(e)

Explication

Exercice 4 : Modèles Imbriqués (Nested Models)

Exercice

Créez un modèle Article avec un titre et un contenu. Créez ensuite un modèle Blog qui contient un nom_blog et une liste_articles (une liste d’objets Article).

Solution

from pydantic import BaseModel
from typing import List

class Article(BaseModel):
  titre: str
  contenu: str

class Blog(BaseModel):
  nom_blog: str
  liste_articles: List[Article]

# Données d'exemple (simulant un JSON reçu)
data = {
"nom_blog": "Mon Blog Tech",
"liste_articles": [
{"titre": "Pydantic est puissant", "contenu": "..."},
{"titre": "Les LLMs en pratique", "contenu": "..."}
]
}

# Validation et instanciation
mon_blog = Blog.model_validate(data)
print(mon_blog.model_dump_json(indent=2))

Explication

Exercice 5 : Validateur Personnalisé (field_validator)

Exercice

Créez un modèle CritiqueProduit avec note (entier) et commentaire (chaîne). Ajoutez un validateur pour s’assurer que la note est toujours comprise entre 1 et 5 (inclus).

Solution

from pydantic import BaseModel, field_validator

class CritiqueProduit(BaseModel):
  note: int
  commentaire: str

@field_validator('note')
@classmethod
def note_must_be_in_range(cls, v: int) -> int:
  if not 1 <= v <= 5:
    raise ValueError('La note doit être entre 1 et 5')
  return v

# Exemple
critique_ok = CritiqueProduit(note=5, commentaire="Excellent !")
print(critique_ok)

try:
  CritiqueProduit(note=6, commentaire="Trop bien !")
except ValueError as e:
  print(e)

Explication

Partie 2 : Pydantic pour Valider les Entrées et Sorties de LLM

Exercice 6 : Extraire une Entité Simple depuis un Texte de LLM

Exercice

Un LLM a généré le texte suivant : “Le ticket de support #TS-481516 concerne un problème de connexion.”. Créez un modèle Pydantic TicketInfo pour extraire uniquement l’ID du ticket. Vous devrez utiliser une étape de pré-traitement (regex) avant de valider.

Solution

import re
from pydantic import BaseModel

class TicketInfo(BaseModel):
  ticket_id: str

llm_output = "Le ticket de support #TS-481516 concerne un problème de connexion."

# Étape 1 : Pré-traitement pour extraire l'information
match = re.search(r'#([A-Z]{2}-\d+)', llm_output)
if match:
  extracted_id = match.group(1)
  # Étape 2 : Validation avec Pydantic
  ticket = TicketInfo(ticket_id=extracted_id)
  print(ticket)
  # > ticket_id='TS-481516'
else:
  print("Aucun ID de ticket trouvé.")

Explication

Exercice 7 : Gérer une Sortie LLM Incomplète

Exercice

Un LLM devait extraire un nom et un email, mais n’a trouvé que le nom : “L’utilisateur s’appelle Jean Dupont.”. Votre modèle Contact requiert un nom et un email. Comment gérer cette situation en utilisant votre modèle ? (Ceci est un exercice de réflexion).

Exercice (Question Théorique) : Que se passera-t-il si vous essayez de créer une instance du modèle Contact (de l’exercice 3) avec uniquement le nom ? Quelle serait une meilleure définition du modèle pour gérer ce cas ?

Solution

L’instanciation Contact(nom=”Jean Dupont”) échouera avec une ValidationError car le champ adresse_email est manquant.

Une meilleure définition du modèle pour gérer les données potentiellement manquantes serait de rendre les champs optionnels :

from pydantic import BaseModel, EmailStr
from typing import Optional

class ParsedContact(BaseModel):
  nom: Optional[str] = None
  adresse_email: Optional[EmailStr] = None

Explication

Exercice 8 : Utiliser des Enum pour Classifier une Sortie LLM

Exercice

Un LLM analyse le sentiment d’un commentaire. La sortie doit être “POSITIF”, “NÉGATIF” ou “NEUTRE”. Créez un modèle Pydantic AnalyseSentiment qui valide que la sortie du LLM est bien l’une de ces trois valeurs.

Solution

from pydantic import BaseModel
from enum import Enum

class Sentiment(str, Enum):
  POSITIF = "POSITIF"
  NEGATIF = "NÉGATIF"
  NEUTRE = "NEUTRE"

class AnalyseSentiment(BaseModel):
  sentiment: Sentiment

# Simulation de sorties LLM
llm_output1 = "POSITIF"
llm_output2 = "INCONNU"

analyse1 = AnalyseSentiment(sentiment=llm_output1)
print(analyse1) # > sentiment=<Sentiment.POSITIF: 'POSITIF'>

try:
  AnalyseSentiment(sentiment=llm_output2)
except ValueError as e:
  print(e)

Explication

Exercice 9 : Utiliser des Alias de Champs (Field)

Exercice

Votre LLM renvoie un JSON avec la clé “user_name”. Cependant, votre code Python interne utilise la convention nom_utilisateur. Créez un modèle Pydantic Profil qui mappe la clé entrante “user_name” à l’attribut nom_utilisateur.

Solution

Explication

Exercice 10 : Parser une Liste d'Objets Structurés

Exercice

Un LLM a extrait une liste de livres d’un texte et l’a formatée en JSON. Créez les modèles Pydantic nécessaires pour valider la structure suivante : une liste de livres, où chaque livre a un titre et un auteur.

Solution

from pydantic import BaseModel, TypeAdapter
from typing import List

class Livre(BaseModel):
  titre: str
  auteur: str

# Simulation de la sortie JSON du LLM
llm_json_output = """
[
  {"titre": "Dune", "auteur": "Frank Herbert"},
  {"titre": "1984", "auteur": "George Orwell"}
]
"""
import json
data = json.loads(llm_json_output)

# Utilisation de TypeAdapter pour valider une liste à la racine
LivresListAdapter = TypeAdapter(List[Livre])
liste_livres_validee = LivresListAdapter.validate_python(data)

print(liste_livres_validee)

Explication

Partie 3 : Demande de Sortie Structurée et Tool Calling

Exercice 11 : Utilisation de instructor pour Forcer une Sortie Structurée

Exercice

Imaginez que vous utilisez la bibliothèque instructor pour patcher un client OpenAI. Votre objectif est d’extraire des informations structurées à partir d’un texte.

Définissez un modèle Pydantic Personne avec les champs nom (str) et age (int).
Écrivez le pseudo-code Python (en simulant l’appel à l’API OpenAI) qui utiliserait instructor pour forcer le LLM à répondre avec une instance du modèle Personne à partir du texte fourni.

Contexte :
Texte d’entrée : “Marc a 32 ans et est ingénieur logiciel. Sa sœur, Léa, a 28 ans.”
Objectif : Extraire les informations sur la première personne mentionnée.

Solution

# Prérequis : supposons que openai est installé et configuré
# pip install instructor openai
import instructor
import openai
from pydantic import BaseModel

# Configuration du client (à adapter avec votre clé API)
# client = openai.OpenAI()

# 1. Patcher le client avec instructor
# client = instructor.patch(client)

# 2. Définir le modèle Pydantic de la réponse attendue
class Personne(BaseModel):
  nom: str
  age: int

# 3. Écrire le pseudo-code de l'appel API
def extraire_personne(texte: str) -> Personne:
  """
  Cette fonction simule l'appel à un LLM via instructor
  pour extraire une entité Personne du texte.
  """
  print(f"Extraction des informations depuis le texte : '{texte}'")

# Ceci est la partie cruciale de l'appel avec instructor
# L'argument `response_model` indique au LLM le format de sortie désiré.
# personne_extraite = client.chat.completions.create(
# model="gpt-3.5-turbo",
# response_model=Personne,
# messages=[
# {"role": "user", "content": f"Extraire le nom et l'âge de la première personne mentionnée dans le texte : {texte}"}
# ]
# )

  # Pour simuler la réponse sans appel API réel :
  personne_extraite = Personne(nom="Marc", age=32)

  return personne_extraite

# Appel de la fonction
texte_source = "Marc a 32 ans et est ingénieur logiciel. Sa sœur, Léa, a 28 ans."
resultat = extraire_personne(texte_source)

print("\nRésultat extrait et validé :")
print(resultat)
# > Résultat extrait et validé :
# > nom='Marc' age=32

Explication

Exercice 12 : Définition d'un Outil (Tool) pour un Agent LLM

Exercice

Vous construisez un agent capable de gérer une playlist musicale. L’un de ses outils est ajouter_chanson_playlist. Cet outil nécessite deux arguments : nom_chanson et nom_artiste. Définissez un modèle Pydantic AjouterChansonParams qui servira à valider les arguments que le LLM fournira pour cet outil.

Solution

from pydantic import BaseModel, Field

class AjouterChansonParams(BaseModel):
  """
  Modèle pour valider les paramètres de l'outil 'ajouter_chanson_playlist'.
  Chaque champ inclut une description pour aider le LLM à comprendre son utilité.
  """
  nom_chanson: str = Field(..., description="Le titre exact de la chanson à ajouter.")
  nom_artiste: str = Field(..., description="Le nom de l'artiste ou du groupe qui a interprété la chanson.")

# Simulation : Le LLM a analysé la requête utilisateur "Ajoute Bohemian Rhapsody de Queen à ma playlist"
# et a généré les arguments suivants.
arguments_llm = {
  "nom_chanson": "Bohemian Rhapsody",
  "nom_artiste": "Queen"
}

# Validation des arguments avant d'appeler la fonction
parametres_valides = AjouterChansonParams(**arguments_llm)
print("Paramètres validés pour l'outil :")
print(parametres_valides)
# > Paramètres validés pour l'outil :
# > nom_chanson='Bohemian Rhapsody' nom_artiste='Queen'

Explication

Exercice 13 : Routage de Tâches basé sur des Modèles Pydantic

Exercice

Un LLM de support client doit router les requêtes vers deux services différents : la facturation ou le support technique.

Créez un modèle RequeteFacturation avec id_facture (str) et montant (float).
Créez un modèle RequeteSupportTechnique avec type_produit (str) et description_probleme (str).
À partir d’une requête utilisateur, le LLM doit choisir l’un des deux modèles et remplir ses champs. Simulez ce processus : validez les données JSON ci-dessous en utilisant le modèle approprié.

Contexte :
Requête utilisateur : “Mon imprimante modèle X-500 ne se connecte plus au WiFi. Le voyant clignote en rouge.”
Sortie JSON du LLM : {‘type_produit’: ‘Imprimante X-500’, ‘description_probleme’: ‘Problème de connexion WiFi, voyant rouge clignotant.’}

Solution

from pydantic import BaseModel
from typing import Union

class RequeteFacturation(BaseModel):
  id_facture: str
  montant: float

class RequeteSupportTechnique(BaseModel):
  type_produit: str
  description_probleme: str

# Sortie simulée du LLM pour la requête donnée
sortie_llm = {
  'type_produit': 'Imprimante X-500', 
  'description_probleme': 'Problème de connexion WiFi, voyant rouge clignotant.'
}

# Logique de routage
def router_requete(donnees: dict):
  try:
    # Essayer de valider en tant que requête technique
    requete = RequeteSupportTechnique(**donnees)
    print("Routage vers : Support Technique")
    return requete
  except ValidationError:
    pass # Ignorer l'erreur et essayer le modèle suivant

  try:
    # Essayer de valider en tant que requête de facturation
    requete = RequeteFacturation(**donnees)
   print("Routage vers : Facturation")
   return requete
  except ValidationError:
    # Si aucun modèle ne correspond
    print("Erreur : Impossible de router la requête, format inconnu.")
    return None

# Simulation du routage
requete_routee = router_requete(sortie_llm)
print("Détails de la requête :", requete_routee)

Explication

Exercice 15 : Cas d'Usage Complet - Mini-Workflow d'Agent

Exercice

Synthétisez les concepts précédents dans un mini-workflow. Un agent doit planifier un voyage.

Étape 1 : Valider l’entrée. Créez un modèle DemandeVoyage pour valider la requête initiale de l’utilisateur : destination (str) et budget (float, doit être > 0).
Étape 2 : Extraction par LLM. Créez un modèle PlanVoyage que le LLM devra remplir. Il doit contenir ville_hotel (str), nombre_etoiles_hotel (int, entre 1 et 5), et activite_suggeree (str).
Étape 3 : Simuler le workflow.
a. Validez une entrée utilisateur simulée avec DemandeVoyage.
b. Utilisez les informations validées pour simuler un prompt et une réponse structurée du LLM.
c. Validez la réponse du LLM avec le modèle PlanVoyage.

Solution

from pydantic import BaseModel, Field, ValidationError

# --- Étape 1: Modèle de validation d'entrée ---
class DemandeVoyage(BaseModel):
  destination: str
  budget: float = Field(..., gt=0) # gt: greater than

# --- Étape 2: Modèle de sortie structurée du LLM ---
class PlanVoyage(BaseModel):
  ville_hotel: str
  nombre_etoiles_hotel: int = Field(..., ge=1, le=5)
  activite_suggeree: str

# --- Étape 3: Simulation du workflow complet ---
def executer_workflow_voyage(entree_utilisateur: dict):
  print("--- Début du Workflow ---")

  # a. Valider l'entrée utilisateur
  try:
    demande = DemandeVoyage(**entree_utilisateur)
    print(f"Demande utilisateur validée : {demande}")
  except ValidationError as e:
    print(f"Erreur dans la demande initiale : {e}")
    return

  # b. Simuler le prompt et la réponse du LLM
  prompt_pour_llm = (
    f"Génère un plan de voyage pour {demande.destination} "
    f"avec un budget de {demande.budget} euros. "
    f"Suggère un hôtel et une activité."
  )
  print(f"\nPrompt (simulé) pour le LLM : \"{prompt_pour_llm}\"")

  # Réponse simulée du LLM (structurée en JSON)
  reponse_llm_json = {
  "ville_hotel": "Paris",
  "nombre_etoiles_hotel": 4,
  "activite_suggeree": "Visite du musée du Louvre"
  }
  print(f"\nRéponse (simulée) du LLM : {reponse_llm_json}")

  # c. Valider la sortie du LLM
  try:
    plan = PlanVoyage(**reponse_llm_json)
    print(f"\nPlan de voyage validé avec succès : {plan}")
    print("--- Fin du Workflow ---")
    return plan
  except ValidationError as e:
    print(f"Erreur : Le LLM a renvoyé une structure invalide : {e}")
    return

# Exécution avec des données valides
entree = {"destination": "Paris", "budget": 1500.0}
plan_final = executer_workflow_voyage(entree)

Exercice 1 : Création d'un Modèle de Base

Exercice

Solution

Explication

Exercice 2 : Gestion des Champs Optionnels et des Valeurs par Défaut

Exercice

Solution

Explication

Exercice 3 : Validation de Types Spécifiques (EmailStr)

Exercice

Solution

Explication

Exercice 4 : Modèles Imbriqués (Nested Models)

Exercice

Solution

Explication

Exercice 5 : Validateur Personnalisé (field_validator)

Exercice

Solution

Explication

Partie 2 : Pydantic pour Valider les Entrées et Sorties de LLM

Exercice 6 : Extraire une Entité Simple depuis un Texte de LLM

Exercice

Solution

Explication

Exercice 7 : Gérer une Sortie LLM Incomplète

Exercice

Solution

Explication

Exercice 8 : Utiliser des Enum pour Classifier une Sortie LLM

Exercice

Solution

Explication

Exercice 9 : Utiliser des Alias de Champs (Field)

Exercice

Solution

Explication

Exercice 10 : Parser une Liste d'Objets Structurés

Exercice

Solution

Explication

Partie 3 : Demande de Sortie Structurée et Tool Calling

Exercice 11 : Utilisation de instructor pour Forcer une Sortie Structurée

Exercice

Solution

Explication

Exercice 12 : Définition d'un Outil (Tool) pour un Agent LLM

Exercice

Solution

Explication

Exercice 13 : Routage de Tâches basé sur des Modèles Pydantic

Exercice

Solution

Explication

Exercice 15 : Cas d'Usage Complet - Mini-Workflow d'Agent

Exercice

Solution

Explication

Plus chez DeepLearn Academy

JOIN US