From Full Stack to AI: All That You Should Know About Pydantic

When you move from full stack development into AI or backend heavy Python work, you start dealing with a lot of data. API inputs, model configs, user payloads, and outputs from ML pipelines. Most bugs at this stage are not about algorithms. They are about bad data.

This is where Pydantic becomes important. It helps you trust your data before you use it. If the data is wrong, Pydantic tells you early, clearly, and in plain Python.

This chapter is written as learning notes from a full stack developer slowly moving into AI.

---

What is Pydantic

Pydantic is a Python library for data validation and parsing.

You define how your data should look using type annotations. Pydantic reads those types, checks the incoming data, converts it when possible, and raises errors when something is wrong.

You do not write extra validation logic again and again. Your model becomes the single source of truth.

Why Pydantic is Important

Powered by type hints

If you already use Python type annotations, you already know most of Pydantic.

You write less code and your editor helps you more.

Fast

Pydantic uses Rust under the hood for validation. You do not feel this directly, but it matters when your app grows.

JSON friendly

Pydantic models can easily convert to Python dicts or JSON. This is useful for APIs and ML pipelines.

Strict and flexible when needed

Sometimes you want strict validation. Sometimes you want Pydantic to convert "123" into 123. You can control this.

Widely used

Libraries like FastAPI, LangChain, and HuggingFace use Pydantic. Learning it once helps everywhere.

The Foundation of Pydantic: Your First Model

What it is

A Pydantic model is a Python class that inherits from BaseModel.

Code example

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    is_active: bool

input_data = {
    "id": 101,
    "name": "Chaicode",
    "is_active": True
}

user = User(**input_data)
print(user)

Output

id=101 name='Chaicode' is_active=True

Explanation

Pydantic takes the dictionary, matches keys with fields, validates the types, and creates an object.

You do not manually unpack or validate anything.

Default Type Conversions in Pydantic

What it is

Pydantic tries to convert values into the expected type when it is safe.

Code example

from pydantic import BaseModel

class Product(BaseModel):
    id: int
    name: str
    price: float
    in_stock: bool = True

product_one = Product(id=1, name="Laptop", price=999.99, in_stock=True)
product_two = Product(id=2, name="Mouse", price=24.33)

Output

id=1 name='Laptop' price=999.99 in_stock=True
id=2 name='Mouse' price=24.33 in_stock=True

Explanation

in_stock has a default value. If you do not pass it, Pydantic fills it automatically.

If you try this:

Product(name="mic")

Pydantic will raise an error because required fields are missing.

Mixing Pydantic with typing

What it is

Pydantic works very well with Python’s typing module.

Code example

from pydantic import BaseModel
from typing import List, Dict, Optional

class Cart(BaseModel):
    user_id: int
    items: List[str]
    quantities: Dict[str, int]

class BlogPost(BaseModel):
    title: str
    content: Optional[str] = None

cart_data = {
    "user_id": 123,
    "items": ["Laptop", "Mouse", "Keyboard"],
    "quantities": {"laptop": 1, "mouse": 2, "keyboard": 3}
}

cart = Cart(**cart_data)
print(cart)

Output

user_id=123 items=['Laptop', 'Mouse', 'Keyboard'] quantities={'laptop': 1, 'mouse': 2, 'keyboard': 3}

Explanation

List, Dict, and Optional help describe real data shapes. Pydantic validates each level automatically.

Adding Validation with Field

What it is

Field lets you add rules like minimum length, value ranges, and descriptions.

Code example

from typing import Optional
from pydantic import BaseModel, Field

class Employee(BaseModel):
    id: int
    name: str = Field(
        ...,
        min_length=3,
        max_length=50,
        description="Employee Name"
    )
    department: Optional[str] = "General"
    salary: float = Field(..., ge=10000)

Explanation

... means the field is required.

ge=10000 means salary must be greater than or equal to 10000.

If invalid data comes in, Pydantic raises a clear error.

Field and Model Validators

Field validator

Used when validation depends on one field.

from pydantic import BaseModel, field_validator

class User(BaseModel):
    username: str

    @field_validator("username")
    def username_length(cls, v):
        if len(v) < 4:
            raise ValueError("username must be at least 4 characters")
        return v

Model validator

Used when validation depends on multiple fields.

from pydantic import BaseModel, model_validator

class SignupData(BaseModel):
    password: str
    confirm_password: str

    @model_validator(mode="after")
    def password_match(cls, values):
        if values.password != values.confirm_password:
            raise ValueError("Passwords do not match")
        return values

Explanation

This is useful for business rules that cannot be checked in isolation.

Computed Fields in Pydantic

What it is

Computed fields are derived values that are not passed by the user.

Code example

from pydantic import BaseModel, computed_field, Field

class Booking(BaseModel):
    user_id: int
    room_id: int
    nights: int = Field(..., ge=1)
    rate_per_night: float

    @computed_field
    @property
    def total_amount(self) -> float:
        return self.nights * self.rate_per_night

booking = Booking(
    user_id=123,
    room_id=456,
    nights=3,
    rate_per_night=100.0
)

print(booking.total_amount)
print(booking.model_dump())

Output

300.0
{'user_id': 123, 'room_id': 456, 'nights': 3, 'rate_per_night': 100.0, 'total_amount': 300.0}

Explanation

The computed value behaves like a normal field during serialization.

Advanced Validation Examples

Normalizing data

from pydantic import BaseModel, field_validator

class User(BaseModel):
    email: str

    @field_validator("email")
    def normalize_email(cls, v):
        return v.lower().strip()

Parsing custom formats

class Product(BaseModel):
    price: str

    @field_validator("price", mode="before")
    def parse_price(cls, v):
        if isinstance(v, str):
            return float(v.replace("$", ""))
        return v

Validating relationships

from datetime import datetime
from pydantic import BaseModel, model_validator

class DateRange(BaseModel):
    start_date: datetime
    end_date: datetime

    @model_validator(mode="after")
    def validate_dates(cls, values):
        if values.start_date >= values.end_date:
            raise ValueError("end_date must be after start_date")
        return values

Nested Models

What it is

Models inside models. Very common in real APIs.

Code example

from pydantic import BaseModel

class Address(BaseModel):
    street: str
    city: str
    postal_code: str

class User(BaseModel):
    id: int
    name: str
    address: Address

user_data = {
    "id": 1,
    "name": "Payal",
    "address": {
        "street": "321 something",
        "city": "Paris",
        "postal_code": "20002"
    }
}

user = User(**user_data)
print(user)

Explanation

Pydantic automatically creates nested objects.

Self Referencing Models

What it is

Used for comments, trees, and recursive structures.

from typing import List, Optional
from pydantic import BaseModel

class Comment(BaseModel):
    id: int
    content: str
    replies: Optional[List["Comment"]] = None

Comment.model_rebuild()

Explanation

This allows a comment to contain replies which are also comments.

Advanced Nested Patterns

You can combine optional models, unions, and deep nesting.

Examples include:

• Optional company details for an employee

• Mixed content like text and images

• Deep address hierarchies like country, state, city

These patterns help model real systems clearly.

Best Practices for Model Design

• Define simple models first

• Build complex models gradually

• Use clear and meaningful names

• Avoid very deep nesting unless required

• Use validators for business rules

• Be careful with circular references

Serialization with model_dump and model_dump_json

Code example

python_dict = user.model_dump()
json_str = user.model_dump_json()

Explanation

• model_dump gives a Python dictionary

• model_dump_json gives a JSON string

This is useful for APIs, logs, and saving data.

---

Closing Thoughts

Pydantic is not just a library. It is a way to think clearly about data.

As a full stack developer moving into AI, strong data foundations matter more than fancy models. Pydantic helps you slow down, define structure, and catch problems early.

Learn it step by step. Build small models. Read errors carefully. Over time, your code becomes calmer and more reliable.

Documenting my Full Stack → AI journey, step by step.

By Payal Kumari