Pydantic: Data Validation That Works

Pydantic changed how Python developers think about data. Before it, validation meant manual checks, cryptic error messages, and boilerplate that duplicated your logic. Now you define data models with Python types and Pydantic handles the rest—validation, error messages, and serialization all ship standard. Every FastAPI endpoint uses it. Every LangChain agent depends on it. It’s that fundamental.

Pydantic cambió cómo los desarrolladores de Python piensan sobre datos. Antes, validación significaba checks manuales, mensajes de error crípticos, y boilerplate que duplicaba tu lógica. Ahora defines modelos de datos con tipos de Python y Pydantic maneja el resto—validación, mensajes de error, y serialización todo incluido. Cada endpoint de FastAPI lo usa. Cada agente de LangChain depende de él. Es tan fundamental.

BaseModel is the entry point. Define a class inheriting from BaseModel, add type annotations, and your data is validated automatically. String field has the wrong type? You get a clear error before your code runs. Required field missing? The error tells you which one. This isn’t defensive programming—it’s confidence. Your functions receive valid data, guaranteed.

BaseModel es el punto de entrada. Define una clase heredando de BaseModel, agrega anotaciones de tipos, y tus datos son validados automáticamente. ¿Campo de string tiene el tipo wrong? Obtienes un error claro antes de que tu código corra. ¿Campo requerido faltante? El error te dice cuál. Esto no es programación defensiva—es confianza. Tus funciones reciben datos válidos, garantizados.

Validators handle custom logic. The @field_validator decorator gives you per-field control—string length, regex patterns, cross-field dependencies. The @model_validator decorator runs checks on the entire model. In v2, the older @validator decorator still works but is deprecated in favor of @field_validator. You maintain full control while keeping validation declarative. Business rules live where they should—in your model, not scattered across functions.

Validadores manejan lógica custom. El decorador @field_validator te da control por campo—longitud de string, patrones regex, dependencias cross-field. El decorador @model_validator corre checks en el modelo entero. En v2, el decorador @validator más antiguo aún funciona pero está deprecado en favor de @field_validator. Mantienes control completo mientras mantienes validación declarativa. Las reglas de negocio viven donde deberían—en tu modelo, no dispersas a través de funciones.

Serialization and deserialization come included. Your model converts to JSON with .model_dump() or .model_json_schema(). JSON converts back to a model with .model_validate(). You don’t write conversion code. You don’t maintain parallel representations. Your data flows between layers without friction—this is why FastAPI uses Pydantic internally.

Serialización y deserialización vienen incluidas. Tu modelo convierte a JSON con .model_dump() o .model_json_schema(). JSON convierte de vuelta a un modelo con .model_validate(). No escribes código de conversión. No mantienes representaciones paralelas. Tu datos fluyen entre capas sin fricción—esto es por qué FastAPI usa Pydantic internamente.

Pydantic v2 rewrote the core in Rust—and the performance numbers are striking. Benchmarks show 5-50x faster validation across workloads. The new Engine architecture separates parsing from validation. The new Hybrid mode lets you opt into performance without breaking existing code. If you were waiting to upgrade from v1, the performance gains are the reason. This isn’t an incremental release—it’s a different library.

Pydantic v2 reescribió el core en Rust—y los números de performance son impactantes. Benchmarks muestran validación 5-50x más rápida en workloads. La nueva Arquitectura Engine separa parsing de validación. El nuevo modo Hybrid te permite optar en performance sin romper código existente. Si estabas esperando hacer upgrade de v1, las ganancias de performance son la razón. Esto no es un release incremental—es una librería diferente.

JSON Schema generation is automatic. Call .model_json_schema() and you get a valid JSON Schema document. Generate forms, validate client-side with JavaScript, document your API—all from your Python types. The schema reflects your validators, your constraints, your field descriptions. Documentation shouldn’t be manual. Documentation should be generated from the source of truth—your model.

Generación de JSON Schema es automática. Llama .model_json_schema() y obtienes un documento JSON Schema válido. Genera forms, valida client-side con JavaScript, documenta tu API—todo desde tus tipos de Python. El schema refleja tus validadores, tus restricciones, tus descripciones de campos. La documentación no debería ser manual. La documentación debería generarse desde la fuente de verdad—tu modelo.

For ML APIs, Pydantic is essential. Every endpoint receives embeddings, tokens, model parameters—input validation prevents bad predictions. Every response returns generated text, scores, classifications—serialization sends clean JSON. Every fallback handles errors—structured error messages help debugging. LangChain uses Pydantic for output parsing. DSPy uses it for optimization constraints. Your ML stack runs on validated data.

Para APIs de ML, Pydantic es esencial. Cada endpoint recibe embeddings, tokens, parámetros de modelo—input validation previene malas predicciones. Cada respuesta retorna texto generado, scores, clasificaciones—serialización envía JSON limpio. Cada fallback maneja errores—mensajes de error estructurados ayudan debuggeo. LangChain usa Pydantic para output parsing. DSPy lo usa para restricciones de optimización. Tu stack de ML corre sobre datos validados.

Integration ecosystem is another strength. FastAPI builds on Pydantic for endpoints. LangChain uses it for structured output. DSPy optimizes against it. Django Ninja uses it. Every modern Python web framework uses it as the validation layer. Your Pydantic models work everywhere. When you’re unsure what validation library to use, the answer is Pydantic—everything else is derivative.

Ecosistema de integración es otra fortaleza. FastAPI construye sobre Pydantic para endpoints. LangChain lo usa para output estructurado. DSPy optimiza contra él. Django Ninja lo usa. Cada framework web moderno de Python lo usa como capa de validación. Tus modelos de Pydantic funcionan en todos lados. Cuando no estás seguro de qué librería de validación usar, la respuesta es Pydantic—todo lo demás es derivativo.

Not a silver bullet. Validation isn’t magic—it catches type errors and simple constraints. Complex business logic still needs custom code. Database models aren’t Pydantic models—ORM integration requires care. Performance at scale means understanding when to validate versus when to trust. But for API development, ML pipelines, and agent code, Pydantic is the standard for a reason. It works.

No es una bala de plata. Validación no es magia—captura errores de tipo y restricciones simples. Lógica de negocio compleja aún necesita código custom. Modelos de base de datos no son modelos de Pydantic—integración con ORM requiere cuidado. Performance a escala significa entender cuándo validar versus cuándo confiar. Pero para desarrollo de APIs, pipelines de ML, y código de agente, Pydantic es el estándar por una razón. Funciona.

References

Referencias