Library of the Week — Pydantic AI

Pydantic AI — type-safe agent framework built on Pydantic’s validation backbone

GitHub · Language: Python · License: MIT

What it does

PydanticAI brings the same structured, type-safe philosophy that made Pydantic essential to FastAPI development directly into LLM agent building. It handles tool registration, dependency injection, structured output validation, and multi-turn conversation — without hiding the underlying model calls behind opaque abstractions. It’s aimed at developers who want production-grade agents without sacrificing debuggability.

Why it stands out

• Model-agnostic with first-class support for OpenAI, Anthropic, Google Gemini, Mistral, and Groq — swap backends by changing one string, not restructuring your code
• Dependency injection built in — agents declare typed dependencies (DB connections, config, API clients) that are injected at runtime, making unit testing agents straightforward without monkeypatching globals
• Structured outputs via Pydantic models — return types are validated automatically; if the model returns malformed JSON, PydanticAI retries with the validation error in context rather than raising and crashing
• Logfire integration out of the box — trace every LLM call, tool execution, and retry in a single structured log stream; invaluable for debugging agents in production

Quick start

from pydantic import BaseModel
from pydantic_ai import Agent

class WeatherResponse(BaseModel):
    city: str
    temperature_c: float
    summary: str

agent = Agent(
    "openai:gpt-5.4-mini",
    result_type=WeatherResponse,
    system_prompt="You are a helpful weather assistant.",
)

result = agent.run_sync("What's the weather like in Tokyo right now?")
print(result.data)
# WeatherResponse(city='Tokyo', temperature_c=28.0, summary='Warm and partly cloudy')

When to use it

• You’re building agents or pipelines that must return validated, typed data rather than free-form strings — and you want retries on validation failure handled automatically
• Your team already uses Pydantic heavily (FastAPI backends, data pipelines) and wants a consistent validation model end-to-end
• You need testable agents — PydanticAI’s dependency injection makes it easy to swap real LLM calls for deterministic fakes in CI

When to skip it

• You need graph-based multi-agent orchestration with complex branching or cycles — LangGraph is purpose-built for that; PydanticAI’s agent composition is comparatively simple
• If your workflow is primarily RAG-heavy with vector store integrations, LlamaIndex has more built-in connectors and retrieval abstractions

The verdict

PydanticAI fills a real gap: it’s the library you reach for when you want agents that feel like normal Python code — typed, testable, and unsurprising — rather than a maze of callbacks and config dicts. The dependency injection model alone makes it substantially easier to write agents you can actually test. If you’re building anything agent-shaped in Python and cleanliness of design matters to you, this should be your starting point.