Pydantic AI : guide d’initiation avec des exemples pratiques

La création d’applications dopées à l’IA conduit souvent à des sorties non structurées, à des incohérences de types et à des problèmes de fiabilité en production. Les approches classiques d’intégration des LLM dans des applications Python manquent de structure et de validation pour répondre aux exigences de la production. Pydantic AI résout ce problème en combinant la validation de données de Pydantic avec un framework d’agents pour les interactions avec des LLM.

Dans ce tutoriel, vous apprendrez à créer des agents IA structurés qui produisent des sorties validées et respectent la sécurité des types. Nous verrons comment définir des agents avec des prompts système, construire des outils (fonctions) que les LLM peuvent appeler pendant une conversation, et mettre en place une validation de sorties structurées. Vous découvrirez aussi comment gérer les dépendances entre composants d’agents et comment diffuser des réponses en streaming pour des applications temps réel. À la fin, vous aurez manipulé concrètement la construction d’applications IA capables de gérer des workflows complexes.

Si vous cherchez une formation pratique pour créer des systèmes d’agents IA, je vous recommande le cours Building Multi-Agent Systems with LangGraph. 

Qu’est-ce que Pydantic AI ?

Pydantic AI est un framework d’agents Python qui apporte structure et sécurité des types aux applications LLM. Contrairement aux intégrations basiques qui renvoient du texte brut, Pydantic AI traite les interactions comme des conversations structurées avec des entrées et sorties validées, ce qui facilite la création d’applications fiables.

Fonctionnalités et bénéfices clés :

• Validation de sorties structurées  — Vos réponses IA respectent automatiquement des modèles Pydantic, évitant les erreurs d’analyse et garantissant la cohérence des données
• Outils fonctionnels  — Les LLM peuvent appeler vos fonctions Python pendant la conversation pour accéder à des données réelles et exécuter des calculs
• Sécurité des types  — Prise en charge complète du typage : moins d’erreurs à l’exécution et meilleure assistance des IDE pour des workflows IA complexes
• Prompts système  — Définissez des consignes claires et constantes pour vos agents IA
• Injection de dépendances  — Partagez proprement le contexte, les connexions à la base de données et les préférences utilisateur entre composants
• Plusieurs modes d’exécution  — Exécutez vos agents en synchrone, en asynchrone ou en streaming temps réel selon vos besoins
• Réutilisabilité des agents  — Créez un agent une fois et réutilisez-le dans toute votre application, à la manière des routeurs FastAPI

Cette approche fait passer l’IA d’une génération de texte imprévisible à des interactions fiables et typées qui s’intègrent naturellement à vos applications Python. Plutôt que de lutter avec l’ingénierie de prompt et le parsing de sorties, vous vous concentrez sur les fonctionnalités utiles pour vos utilisateurs.

Prérequis

Avant de commencer ce tutoriel, prévoyez :

Connaissances requises :

• Fondamentaux de Python : être à l’aise avec les classes et les fonctions
• Notions d’asynchrone en Python
• Bases de Pydantic : comprendre les modèles, la validation de champs et les annotations de type
• Familiarité avec les LLM : Notions de base sur le fonctionnement des modèles de langage et les prompts

Utile mais non obligatoire :

• Concepts d’agents : une première exposition aux agents IA et aux appels d’outils, même si nous le verrons

Configuration requise :

• Python 3.9 ou supérieur
• Clés d’API OpenAI et Anthropic
• Bases de la ligne de commande pour installer des paquets

Si vous débutez avec Pydantic, leur documentation officielle couvre très bien les bases. Pour les fondamentaux des LLM, tout guide d’initiation à ChatGPT ou à des modèles similaires suffira pour suivre.

Premiers pas avec Pydantic AI

Tout au long de ce tutoriel, nous construirons un agent d’analyse des données pour comprendre la performance des ventes par région et par produit. L’agent commencera simplement et gagnera en sophistication à mesure que nous ajouterons des outils sur mesure, des sorties structurées et des capacités de streaming.

Installation et configuration

Avant d’écrire le moindre code, installons Pydantic AI et préparons l’environnement :

pip install pydantic-ai

Vous aurez aussi besoin d’une clé d’API OpenAI et d’une clé Anthropic. Définissez-les en variables d’environnement :

export OPENAI_API_KEY="your-api-key-here"export ANTHROPIC_API_KEY="your-api-key-here"

> Nous utiliserons à la fois des modèles OpenAI et Anthropic, certaines fonctionnalités de Pydantic AI n’étant disponibles que chez l’un ou l’autre.

Pour nos exemples d’analyse, nous utiliserons aussi pandas pour la manipulation de données :

pip install pandas

Créer votre premier agent

Commençons par l’agent le plus simple : il répond à des questions de base sur les données de ventes. Dans Pydantic AI, un agent est l’interface principale pour interagir avec un LLM (exécutez le code suivant dans un script Python) :

from pydantic_ai import Agent# Create a basic sales analysis agentsales_agent = Agent(   'openai:gpt-4o',   system_prompt=(       "You are a data analyst specializing in sales performance. "       "Provide clear, actionable insights based on the data provided."   ))# Run the agent with a simple questionresult = sales_agent.run_sync("What are the key metrics I should track for sales performance? Answer in two sentences.")print(result.output)

Sortie :

Key metrics to track for sales performance include conversion rate, which measures the percentage of leads that result in sales, and average deal size, indicating the average revenue earned per transaction. Additionally, monitoring customer acquisition cost (CAC) and customer lifetime value (CLV) helps evaluate the efficiency and profitability of sales efforts.

Cela crée un agent qui comprend son rôle d’analyste commercial et peut fournir des recommandations pertinentes. Le system_prompt donne au LLM le contexte des réponses attendues, tandis que run_sync() exécute l’agent et renvoie un résultat.

Ici, la fonction run_sync() ne fonctionne que dans des scripts Python. Pour exécuter des agents dans un Jupyter Notebook, utilisez la syntaxe suivante :

result = await agent.run("...")print(result.output)

Changer de LLM et régler ses paramètres

Pydantic AI prend en charge plusieurs fournisseurs de LLM et vous permet de personnaliser le comportement des modèles. Voici comment expérimenter différentes options :

# Creating agents with different modelsclaude_agent = Agent('anthropic:claude-3-5-sonnet-20241022', system_prompt="You are a sales analyst.")gpt_mini_agent = Agent('openai:gpt-4o-mini', system_prompt="You are a sales analyst.")

Chaque modèle apporte des capacités différentes à votre analyse. Les modèles Claude excellent en raisonnement détaillé et en analyses complexes, idéals pour obtenir des insights fouillés. GPT-4o-mini offre des réponses plus rapides et à moindre coût, parfait pour des questions rapides ou de gros volumes de requêtes.

Au-delà du choix du modèle, vous pouvez affiner son comportement via des paramètres :

# Add model-specific settingsconfigured_agent = Agent(   'openai:gpt-4o',   system_prompt="You are a sales analyst.",   model_settings={       'temperature': 0.3,  # More focused, less creative responses       'max_tokens': 500,   # Limit response length   })

Paramètres personnalisables :

• temperature — Contrôle la créativité (0,0 = focalisé, 1,0 = créatif)
• max_tokens — Limite la longueur de la réponse
• top_p — Alternative à temperature pour gérer l’aléatoire

Pour l’analyse de données, des valeurs de temperature basses (0,1–0,3) fonctionnent généralement mieux, car vous recherchez des réponses factuelles et cohérentes plutôt que créatives. Définir max_tokens aide à maîtriser la longueur des sorties, utile pour des synthèses concises ou la maîtrise des coûts d’API.

Utiliser des outils dans les agents

Jusqu’ici, notre agent d’analyse ne travaille qu’avec les informations passées dans les prompts. Or l’analyse réelle exige souvent d’accéder à des sources externes, d’exécuter des calculs ou de se connecter à des systèmes métier. C’est là que les outils interviennent : ils donnent à votre agent la capacité d’agir et de récupérer des informations pendant la conversation.

Outils intégrés

Les outils intégrés sont des fonctions prêtes à l’emploi fournies par les prestataires de LLM. Pydantic AI prend en charge la recherche web et l’exécution de code qui s’exécutent directement sur l’infrastructure du fournisseur.

Commençons par la recherche web, idéale pour récupérer des informations de marché à jour :

from pydantic_ai import Agent, WebSearchTool# Create an agent with web search abilitiesmarket_research_agent = Agent(   'anthropic:claude-3-5-sonnet-20241022',   builtin_tools=[WebSearchTool()],   system_prompt=(       "You are a sales analyst. Use web search to find current information. "       "Keep responses to 3-4 sentences maximum."   ))# Get current market informationresult = market_research_agent.run_sync(   "Search for 2025 laptop sales trends and average selling prices. Give me the main trends.")print(result.output)

Let me search for current laptop sales trends.Based on the search results, here are the key laptop market trends for 2025:…

Vous passez ainsi d’analyses sur données historiques à une analyse enrichie par des données de marché en temps réel. L’agent peut comparer vos performances aux tendances actuelles du secteur.

Ajoutons maintenant l’exécution de code pour les calculs et le traitement des données :

from pydantic_ai import Agent, CodeExecutionTool# Agent that can run calculations and data analysiscalculation_agent = Agent(   'anthropic:claude-sonnet-4-0',   builtin_tools=[CodeExecutionTool()],   system_prompt=(       "You are a data analyst. Use code to perform calculations and create visualizations. "       "Show your work and provide clear explanations."   ))# Analyze sales data with calculationsresult = calculation_agent.run_sync("""I have sales data for Q1 2025:- North region: 150 laptops at $1,500 each, 320 phones at $500 each- South region: 89 laptops at $1,500 each, 245 phones at $500 each - East region: 201 laptops at $1,500 each, 180 phones at $500 each- West region: 167 laptops at $1,500 each, 290 phones at $500 eachCalculate total revenue by region and create a simple chart showing the results.""")print(result.output)```plaintext## SummaryBased on the Q1 2025 sales data analysis, here are the key findings:**Total Revenue by Region:**- **West Region**: $395,500 (highest)- **East Region**: $391,500- **North Region**: $385,000- **South Region**: $256,000 (lowest)

L’exécution de code dépasse la simple réponse textuelle pour réaliser une analyse computationnelle. Votre agent peut exécuter des calculs complexes, créer des visualisations et traiter des données impossibles à gérer par simple dialogue. L’objet résultat contient à la fois l’analyse et les fichiers générés pendant l’exécution, que vous pouvez télécharger.

Écrire des outils personnalisés

Si les outils intégrés sont utiles, vous aurez souvent besoin d’outils adaptés à vos systèmes métier. Les outils personnalisés sont des fonctions Python que votre agent peut appeler pendant la conversation.

Créons des outils qui calculent des indicateurs commerciaux courants :

from pydantic_ai import Agent# Create an agent with custom business toolssales_agent = Agent(   'anthropic:claude-sonnet-4-0',   system_prompt=(       "You are a sales analyst. Use tools to calculate metrics and analyze business data. "       "Give concise answers in 3-4 sentences maximum."   ))@sales_agent.tool_plaindef calculate_conversion_rate(leads: int, sales: int) -> str:   """Calculate conversion rate from leads to sales."""   if leads == 0:       return "Cannot calculate conversion rate: no leads provided"     conversion_rate = (sales / leads) * 100   return f"Conversion rate: {conversion_rate:.2f}% ({sales} sales from {leads} leads)"@sales_agent.tool_plaindef calculate_average_order_value(total_revenue: float, total_orders: int) -> str:   """Calculate average order value."""   if total_orders == 0:       return "Cannot calculate AOV: no orders provided"     aov = total_revenue / total_orders   return f"Average Order Value: ${aov:.2f} (${total_revenue:,.0f} revenue from {total_orders} orders)"# Use the custom toolsresult = sales_agent.run_sync(   "Calculate conversion rate for 500 leads that resulted in 75 sales, and AOV for $180,000 revenue from 120 orders")print(result.output)

Your conversion rate is 15.00%, meaning you're successfully converting 75 out of every 500 leads into sales. The average order value is $1,500.00, indicating strong revenue per transaction. These metrics suggest effective sales processes with high-value customers, though there's room to improve lead conversion rates.

Ces outils gèrent des calculs spécifiques récurrents pour votre activité. Le taux de conversion mesure l’efficacité marketing, tandis que la valeur moyenne de commande suit les habitudes de dépense. Les outils personnalisés relient votre agent à votre logique métier.

Pour des schémas d’outils plus avancés, incluant l’injection de dépendances et la gestion des erreurs, consultez la documentation complète sur les outils.

Utiliser des sorties structurées

Jusqu’à présent, nos agents renvoyaient du texte libre, pratique pour l’exploration mais problématique en production. Si vous devez traiter les réponses par code, extraire des points précis ou intégrer l’IA à d’autres systèmes, vous avez besoin d’une structure garantie.

Supposons que vous vouliez analyser des ventes et recevoir toujours les mêmes indicateurs. En texte libre, le format varie. Avec des sorties structurées, vous définissez précisément ce que vous attendez :

from pydantic import BaseModelfrom pydantic_ai import Agentclass SalesInsight(BaseModel):   total_revenue: float   best_performing_region: str   worst_performing_region: str   recommendation: str# Create an agent that returns structured analysisanalysis_agent = Agent(   'anthropic:claude-sonnet-4-0',   output_type=SalesInsight,   system_prompt="Analyze sales data and provide structured insights with clear recommendations.")# Get structured analysisresult = analysis_agent.run_sync("""Q1 2025 sales data:- North: $385,000 revenue (470 units)- South: $256,000 revenue (334 units) - East: $391,500 revenue (381 units)- West: $395,500 revenue (457 units)Analyze this data and provide insights.""")print(f"Total Revenue: ${result.output.total_revenue:,.0f}")print(f"Best Region: {result.output.best_performing_region}")print(f"Recommendation: {result.output.recommendation}")

Total Revenue: $1,428,000Best Region: WestRecommendation: Focus on improving South region performance through targeted marketing and sales training, as it significantly underperforms with only $256,000 revenue. The West region's success ($395,500) should be analyzed and replicated across other regions. Additionally, investigate why East region has the lowest average selling price per unit ($1,028) compared to West's highest ($865) - there may be pricing strategy opportunities.

Notez le paramètre output_type=SalesInsight. Il impose à l’agent de renvoyer un objet SalesInsight avec exactement ces quatre champs. Ni plus ni moins. Le résultat revient dans result.output, automatiquement validé et typé.

Les sorties structurées fonctionnent en convertissant votre modèle Pydantic en schéma JSON que le LLM suit. L’IA ne peut pas s’écarter de votre structure : si elle renvoie autre chose, Pydantic AI lui demande de réessayer.

Pour des analyses plus complexes, vous pouvez imbriquer des modèles et utiliser des listes :

from typing import Listfrom pydantic import BaseModelclass RegionalMetrics(BaseModel):   region: str   revenue: float   units_sold: int   average_price: float   performance_rating: str  # "excellent", "good", "needs_improvement"class ComprehensiveAnalysis(BaseModel):   total_revenue: float   total_units: int   regional_breakdown: List[RegionalMetrics]   top_performer: str   areas_for_improvement: List[str]   quarterly_grade: str# Agent with detailed structured outputdetailed_agent = Agent(   'anthropic:claude-sonnet-4-0',   output_type=ComprehensiveAnalysis,   system_prompt=(       "Provide comprehensive sales analysis with detailed regional metrics. "       "Rate each region's performance and give an overall quarterly grade (A-F)."   ))result = detailed_agent.run_sync("""Analyze Q1 2025 performance:- North: $385k revenue, 470 units- South: $256k revenue, 334 units- East: $391.5k revenue, 381 units - West: $395.5k revenue, 457 units""")# Access structured datafor region in result.output.regional_breakdown:   print(f"{region.region}: {region.performance_rating} (${region.average_price:.2f} avg price)")print(f"Quarterly Grade: {result.output.quarterly_grade}")

North: B ($819.15 avg price)South: C ($766.47 avg price)East: A ($1027.56 avg price)West: A- ($865.43 avg price)Quarterly Grade: B+

Cette méthode transforme l’IA en un traitement de données fiable. Vous pouvez stocker chaque indicateur régional en base, déclencher des alertes selon les notes ou générer automatiquement des tableaux de bord. Pas de regex, pas de formats variables : des données propres et validées, systématiquement.

Le paramètre output_type accepte tout modèle Pydantic, dataclass Python, TypedDict, ou même des types simples comme int ou list[str]. Pour vos workflows d’analyse, cela permet de créer des pipelines robustes où l’analyse IA alimente directement vos systèmes métier.

Messages et historique de chat dans les agents Pydantic

Avec des agents d’analyse, les échanges s’étalent souvent sur plusieurs interactions. Vous commencez par des tendances globales, puis vous creusez une région ou comparez des périodes. Les messages et l’historique permettent de garder le contexte d’une interaction à l’autre.

Accéder à l’historique

À chaque exécution, Pydantic AI conserve toute la conversation. Vous pouvez y accéder pour comprendre le déroulé ou poursuivre plus tard :

from pydantic_ai import Agent# Create our sales analysis agentsales_agent = Agent(   'anthropic:claude-sonnet-4-0',   system_prompt="You are a sales analyst. Provide clear, concise analysis.")# First questionresult1 = sales_agent.run_sync("What are the main KPIs I should track for Q1 2025 sales?")print(result1.output)# Access the conversation historyall_messages = result1.all_messages()print(f"Total messages in conversation: {len(all_messages)}")# Just the new messages from this runnew_messages = result1.new_messages()print(f"New messages from this run: {len(new_messages)}")

Here are the essential KPIs to track for Q1 2025 sales:...Total messages in conversation: 2New messages from this run: 2

La méthode all_messages() renvoie tout : prompts système, questions et réponses. new_messages() ne renvoie que ce qui s’est passé pendant l’exécution courante : utile pour suivre l’évolution d’une longue conversation.

Poursuivre une conversation avec l’historique

Pour capitaliser sur les échanges précédents, passez l’historique au prochain appel d’agent. L’agent se souvient ainsi de ce qui a été dit :

# Continue the conversation from where we left offresult2 = sales_agent.run_sync(   "How should I calculate conversion rates for each of those KPIs?",   message_history=result1.all_messages())print(result2.output)# The agent now has context from both interactionsprint(f"Full conversation length: {len(result2.all_messages())}")# Ask a follow-up that references the entire conversationresult3 = sales_agent.run_sync(   "Which of these metrics would be most important for a monthly executive report?",   message_history=result2.all_messages())print(result3.output)

Chaque nouvel appel enrichit le contexte. L’agent se souvient de vos questions et de ses propres réponses, pour une analyse cohérente.

Stocker et charger les messages en JSON

Pour une conservation long terme ou le partage entre systèmes, vous pouvez sérialiser l’historique en JSON :

import json# Get the conversation as JSONconversation_json = result3.all_messages_json()# Save to filewith open('sales_analysis_conversation.json', 'w') as f:   f.write(conversation_json.decode('utf-8'))print("Conversation saved to JSON file")# Load it back laterwith open('sales_analysis_conversation.json', 'r') as f:   loaded_conversation = f.read()# You can now use this loaded conversation in a new agent run# (Note: You'd need to convert back from JSON to message objects for actual use)print(f"Loaded conversation size: {len(loaded_conversation)} characters")

La méthode all_messages_json() renvoie la conversation en octets JSON, idéal pour une base de données, une API ou l’archivage. Il existe aussi new_messages_json() si vous ne souhaitez sauvegarder que la dernière portion.

Cette approche permet de créer des workflows d’analyse persistants : sauvegarder les sessions par client, reprendre une enquête sur plusieurs jours, ou partager le contexte entre membres d’une équipe.

Travailler avec des images et des documents

L’analyse réelle dépasse le texte et les chiffres. Il faut parfois analyser des graphiques, extraire des données de PDF ou interpréter des visualisations. Pydantic AI prend en charge les images et documents en entrée, afin que vos agents exploitent directement ces sources riches.

Analyser des images via des URLs

Lorsque vos graphiques sont en ligne, pointez l’agent dessus :

from pydantic_ai import Agent, ImageUrl# Create an agent that can analyze visual datavisual_agent = Agent(   'anthropic:claude-sonnet-4-0',   system_prompt="You are a data analyst who can interpret charts, graphs, and business documents.")# Analyze a sales chart from a URLresult = visual_agent.run_sync([   "What are the main trends shown in this sales chart? Give me 3 key takeaways.",   ImageUrl(url='https://example.com/q1-sales-chart.png')])print(result.output)

L’agent peut identifier le type de graphique, lire les axes, déceler des tendances et fournir des insights comme le ferait un analyste.

Travailler avec des images locales

Pour des images locales — captures d’écran d’outils BI ou exports Excel — utilisez BinaryContent :

from pathlib import Pathfrom pydantic_ai import Agent, BinaryContent# Load a local sales dashboard screenshotdashboard_path = Path('sales_dashboard_jan_2025.png')result = visual_agent.run_sync([   "Analyze this sales dashboard. What metrics need attention based on what you see?",   BinaryContent(       data=dashboard_path.read_bytes(),       media_type='image/png'   )])print(result.output)

C’est idéal pour des rapports automatisés : capturez vos tableaux de bord, puis laissez l’IA fournir l’analyse écrite.

Analyser des documents via des URLs

Beaucoup de documents métier sont partagés par URL : rapports intranet, PDF en cloud, articles de recherche publics :

from pydantic_ai import Agent, DocumentUrl# Create an agent for document analysisdoc_agent = Agent(   'anthropic:claude-sonnet-4-0',   system_prompt="Extract and summarize business-relevant insights from documents.")# Analyze a quarterly report PDFresult = doc_agent.run_sync([   "Read this quarterly earnings report and summarize the revenue trends and outlook.",   DocumentUrl(url='https://company.com/reports/q1-2025-earnings.pdf')])print(result.output)

L’agent peut lire des documents entiers, extraire les points saillants et proposer des synthèses qui feraient gagner un temps précieux.

Traiter des documents locaux

Pour des documents locaux — exports, contrats, présentations — utilisez BinaryContent :

from pathlib import Pathfrom pydantic_ai import Agent, BinaryContent# Load a local Excel export saved as PDFreport_path = Path('monthly_sales_analysis_jan_2025.pdf')result = doc_agent.run_sync([   "Extract the key performance metrics from this monthly sales report and identify any concerning trends.",   BinaryContent(       data=report_path.read_bytes(),       media_type='application/pdf'   )])print(result.output)

Les possibilités d’automatisation sont puissantes : traitement de lots de rapports, extraction de données de factures, analyse de clauses contractuelles — autant de tâches habituellement manuelles.

Points importants :

Les formats supportés varient selon les modèles. La plupart gèrent PNG, JPEG et PDF, mais vérifiez la documentation de votre modèle. Certains, comme Google Vertex AI, accèdent directement au stockage cloud, d’autres téléchargent le contenu.

Pour les workflows d’analyse, cette capacité multimodale comble l’écart entre vos rapports visuels et des insights pilotés par l’IA, afin d’automatiser l’analyse de tous vos documents métier au quotidien.

Activer le streaming dans Pydantic AI

Sur des analyses complexes, vous voulez voir les résultats au fil de l’eau plutôt que d’attendre la fin. Le streaming permet d’observer l’analyse en temps réel, très utile pour des questions détaillées sur la performance commerciale.

Pydantic AI propose le streaming via la méthode run_stream(). Voici comment l’utiliser :

import asynciofrom pydantic_ai import Agent# Create our sales analysis agentsales_agent = Agent(   'anthropic:claude-sonnet-4-0',   system_prompt=(       "You are a data analyst specializing in sales performance. "       "Provide detailed, actionable insights based on the data provided."   ))async def demo_streaming():   question = """   Analyze this sales scenario: Our company sold 1,200 laptops and 2,300 phones   last quarter across 4 regions. Laptops average $1,500 each, phones $500 each.   What are the key insights and recommendations?   """     async with sales_agent.run_stream(question) as result:       async for text in result.stream_text():           print(text, end='', flush=True)# Run the streaming analysisasyncio.run(demo_streaming())

Comprendre la syntaxe de streaming :

Le async with ouvre une connexion avec le LLM, maintenue tant que des fragments de texte arrivent. C’est comme un appel : on ouvre, on échange, puis on ferme proprement.

La boucle async for traite chaque fragment dès sa réception. Notez que stream_text() régénère le texte complet à chaque fois : vous obtenez ainsi « Hello », puis « Hello world », etc. Vous gardez le contexte complet, au prix d’un affichage parfois répétitif.

Pourquoi l’async et asyncio vont de pair :

Poser une question à un LLM prend du temps : 3–10 secondes en général. Pendant ce temps, le modèle envoie de petits morceaux toutes les 50–200 ms.

Sans async, votre programme reste bloqué en attente. Avec async, la boucle d’événements de Python alterne les tâches : votre appli reste réactive et peut gérer plusieurs conversations en parallèle.

asyncio.run() lance le processus : il crée la boucle d’événements. Quand vous appelez asyncio.run(demo_streaming()), il met en place l’environnement où vos fonctions async peuvent se mettre en pause et reprendre selon les réponses du LLM.

Créons maintenant une fonction réutilisable qui n’affiche que les deltas de texte pour un rendu plus fluide :

from pydantic_ai.messages import PartDeltaEvent, TextPartDeltaasync def stream_agent_response(agent: Agent, task: str):   """   Stream a response from any Pydantic AI agent showing just new text deltas.   """   async def event_handler(ctx, event_stream):       async for event in event_stream:           if isinstance(event, PartDeltaEvent) and isinstance(               event.delta, TextPartDelta           ):               print(event.delta.content_delta, end="", flush=True)   # Use agent.run() with event_stream_handler for proper streaming   result = await agent.run(task, event_stream_handler=event_handler)   print()  # Add a newline when streaming is complete   return result# Usage exampleresponse = asyncio.run(stream_agent_response(   sales_agent,   "What are the top 3 metrics I should track for quarterly sales analysis?"))

Décryptage de la fonction de streaming :

La fonction stream_agent_response() produit un streaming plus naturel en n’affichant que le texte nouvellement généré. Fonctionnement :

1. Gestionnaire d’événements : la fonction interne event_handler() écoute des événements précis (PartDeltaEvent avec TextPartDelta) qui représentent de nouveaux fragments de texte.
2. Contenu delta : au lieu de recevoir le texte régénéré à chaque fois, event.delta.content_delta ne renvoie que les nouveaux mots ou caractères, pour un effet machine à écrire.
3. Exécution de l’agent : on utilise agent.run() avec event_stream_handler pour brancher le gestionnaire et contrôler finement l’affichage.
4. Sortie temps réel : print(event.delta.content_delta, end="", flush=True) affiche immédiatement chaque fragment, sans saut de ligne, pour un flux continu.

Vous obtenez ainsi l’impression de voir l’IA raisonner en direct, plutôt que d’attendre une réponse complète ou de subir du texte répété. Nous réutiliserons cette fonction pour illustrer le streaming dans nos exemples d’analyse.

Conclusion

Tout au long de ce tutoriel, vous avez découvert Pydantic AI à travers des exemples concrets d’analyse. Vous avez appris à créer des agents avec prompts système, à ajouter des outils intégrés et personnalisés, à structurer les sorties avec des modèles Pydantic et à diffuser les réponses en streaming. L’ensemble forme des systèmes IA qui agissent comme de véritables partenaires d’analyse, bien au-delà d’un simple chatbot.

Les usages dépassent largement nos exemples de ventes. Vous pouvez désormais bâtir des agents qui lisent vos sources de données, appliquent vos règles métier et renvoient des résultats compatibles avec vos systèmes. Qu’il s’agisse d’automatiser des rapports, d’analyser des retours client ou de traiter des données financières, Pydantic AI offre la structure et la fiabilité requises pour la production.

Si vous souhaitez créer des systèmes multi-agents avec LangGraph, découvrez notre cours pratique.