Pydantic AI

Pydantic AI: Le framework d'agents GenAI

Pydantic AI est un framework d'agents Python conçu pour faciliter la construction rapide, fiable et transparente d'applications et de workflows de qualité production tirant parti de l'IA générative. Il vise à apporter la conception ergonomique de FastAPI au développement d'applications et d'agents GenAI.

Qu'est-ce que Pydantic AI ?

Pydantic AI est un outil conçu pour aider les développeurs à créer des applications avec l'IA générative rapidement et efficacement. Il exploite la validation Pydantic et les fonctionnalités Python modernes pour offrir une expérience de développement fluide.

Caractéristiques principales :

• Développé par l'équipe Pydantic: Accès direct à la source de la validation Pydantic, qui est utilisée dans de nombreux SDK d'IA populaires.
• Agnostique au modèle: Prend en charge une large gamme de modèles et de fournisseurs, notamment OpenAI, Anthropic, Gemini, et bien d'autres. Des modèles personnalisés peuvent également être facilement mis en œuvre.
• Observabilité transparente: S'intègre à Pydantic Logfire pour le débogage en temps réel, la surveillance des performances et le suivi des coûts. Prend également en charge d'autres plateformes compatibles OpenTelemetry.
• Entièrement sûr au niveau des types: Conçu pour fournir un contexte complet pour la saisie semi-automatique et la vérification des types, réduisant ainsi les erreurs d'exécution.
• Évaluations puissantes: Permet des tests et une évaluation systématiques des performances et de la précision de l'agent.
• MCP, A2A et AG-UI: Intègre des normes pour l'accès des agents aux outils et aux données externes, l'interopérabilité avec d'autres agents et la création d'applications interactives.
• Approbation des outils par l'humain dans la boucle: Permet de signaler les appels d'outils qui nécessitent une approbation avant l'exécution.
• Exécution durable: Permet de créer des agents capables de maintenir la progression en cas de défaillance de l'API et de redémarrage de l'application.
• Sorties diffusées: Fournit une diffusion continue de la sortie structurée avec validation immédiate.
• Prise en charge des graphes: Offre un moyen puissant de définir des graphes à l'aide d'indications de type pour les applications complexes.

Comment fonctionne Pydantic AI ?

Pydantic AI fonctionne en fournissant un framework qui simplifie le développement d'agents d'IA. Il utilise des modèles Pydantic pour définir la structure des entrées et des sorties de l'agent, et il fournit des outils pour connecter l'agent à divers LLM et autres services.

Comment utiliser Pydantic AI ?

1. Installation: Installez le package pydantic_ai.

2. Utilisation de base: Créez une instance Agent avec le modèle et les instructions spécifiés.

   from pydantic_ai import Agent
   
   agent = Agent(
       'anthropic:claude-sonnet-4-0',
       instructions='Soyez concis, répondez en une phrase.',
   )
   
   result = agent.run_sync('D'où vient "hello world" ?')
   print(result.output)
   """
   

La première utilisation connue de "hello, world" remonte à un manuel de 1974 sur le langage de programmation C. """ ```

3. Utilisation avancée: Ajoutez des outils, des instructions dynamiques et des sorties structurées pour créer des agents plus puissants.

À qui s'adresse Pydantic AI ?

Pydantic AI est idéal pour :

• Les développeurs souhaitant créer des applications et des workflows GenAI de manière efficace.
• Les équipes ayant besoin d'agents d'IA robustes, sûrs au niveau des types et observables.
• Les projets qui doivent s'intégrer à divers LLM et services.

Exemple d'outils et d'injection de dépendances

Pydantic AI facilite l'injection de dépendances, ce qui est utile lorsque vous devez injecter des données ou des services dans vos outils. Vous pouvez définir votre classe de dépendance et la transmettre à l'agent. Vous trouverez ci-dessous un exemple de code de création d'un agent de support pour une banque avec Pydantic AI :

from dataclasses import dataclass

from pydantic import BaseModel, Field
from pydantic_ai import Agent, RunContext

from bank_database import DatabaseConn


@dataclass
class SupportDependencies:
    customer_id: int
    db: DatabaseConn


class SupportOutput(BaseModel):
    support_advice: str = Field(description='Conseils renvoyés au client')
    block_card: bool = Field(description='Indique s'il faut bloquer la carte du client')
    risk: int = Field(description='Niveau de risque de la requête', ge=0, le=10)


support_agent = Agent(
    'openai:gpt-5',
    deps_type=SupportDependencies,
    output_type=SupportOutput,
    instructions=(
        'Vous êtes un agent de support dans notre banque, fournissez le '
        'support client et évaluez le niveau de risque de leur requête.'
    ),
)


@support_agent.instructions
async def add_customer_name(ctx: RunContext[SupportDependencies]) -> str:
    customer_name = await ctx.deps.db.customer_name(id=ctx.deps.customer_id)
    return f"Le nom du client est {customer_name!r}"


@support_agent.tool
async def customer_balance(
    ctx: RunContext[SupportDependencies], include_pending: bool
) -> float:
    """Renvoie le solde actuel du compte du client."""
    return await ctx.deps.db.customer_balance(
        id=ctx.deps.customer_id,
        include_pending=include_pending,
    )

Instrumentation avec Pydantic Logfire

Pour surveiller les agents en action, Pydantic AI s'intègre de manière transparente à Pydantic Logfire, la plateforme d'observabilité OpenTelemetry, qui permet le débogage en temps réel, la surveillance des performances basée sur les évaluations, ainsi que le suivi du comportement, du traçage et des coûts. Le code d'exemple :

...from pydantic_ai import Agent, RunContext
from bank_database import DatabaseConn
import logfire

logfire.configure()
logfire.instrument_pydantic_ai()
logfire.instrument_asyncpg()
...support_agent = Agent(
    'openai:gpt-4o',
    deps_type=SupportDependencies,
    output_type=SupportOutput,
    system_prompt=(
        'Vous êtes un agent de support dans notre banque, fournissez le '
        'support client et évaluez le niveau de risque de leur requête.'
    ),
)

Pourquoi choisir Pydantic AI ?

Pydantic AI offre une approche simplifiée de la création d'applications GenAI. Sa base sur la validation Pydantic, sa conception agnostique au modèle, son observabilité transparente et son environnement sûr au niveau des types en font un choix convaincant pour les développeurs qui recherchent l'efficacité et la fiabilité.

Prochaines étapes

Pour explorer Pydantic AI plus en détail :

• Installez Pydantic AI et suivez les exemples.
• Consultez la documentation pour une compréhension plus approfondie.
• Consultez la référence de l'API pour comprendre l'interface de Pydantic AI.
• Rejoignez le canal Slack ou soumettez un problème sur GitHub pour toute question.