Pydantic
Build · Test
Define typed schemas and validate the structured data entering your application.
All capabilities · LLM application development
Get reliable structured outputs from LLMs
JSON schemas, function schemas, validation with Pydantic/Zod, handling malformed outputs.
Explore 4 tools for this projectMarket relevance
Which roles ask for this — and how often
Share of job postings in India, per role, that name this capability.
What employers mean
You should be able to…
- Define a JSON schema/Pydantic model and force the LLM to return data matching it
- Use function/tool calling to extract structured fields from unstructured text (invoices, resumes, tickets)
- Validate and repair malformed LLM JSON output before it hits downstream code
- Handle nested/optional fields and enums in extraction schemas
- Fall back gracefully when the model returns invalid structure (retry, default, or flag for review)
- Chain structured extraction with a database write or API call
Needs first: Integrate LLM APIs into an application
Learn — free, link-checked
The few resources that matter
Read · beginner · 40 min · docs.pydantic.dev
Pydantic Documentation
Pydantic is the de facto schema/validation layer paired with every Python LLM structured-output pipeline. — Pydantic
Read · intermediate · 30 min · platform.openai.com
Structured Outputs
Explains JSON-schema-constrained generation directly from the provider that popularized the strict-schema approach. — OpenAI
Read · intermediate · 30 min · python.useinstructor.com
Instructor: Structured Outputs for LLMs
The most widely used library for getting validated Pydantic objects out of any LLM with automatic retries on bad output. — Jason Liu / instructor
Read · intermediate · 35 min · docs.anthropic.com
Tool Use (Function Calling) with Claude
Canonical reference for defining tool schemas and getting reliable structured calls back from Claude. — Anthropic
Tools for practice
Choose a tool for the job
Start with one tool for each part of your project. You don’t need to learn them all.
4 tools to explore
Instructor
Build · Test
Request structured model outputs and validate them against a schema.
OpenAI API
Build · Test
Connect model calls, tool use and structured responses to your own application.
Claude API
Build · Test
Build model-backed features with messages, tool use and responses you can evaluate.
Practices & references
- JSON Schema
- Validation and retries
Practice
Schema-validated field extractor for GST invoices
Write a generator that emits 20 synthetic GST invoices, varying vendor layout, GSTIN format, HSN codes and CGST/SGST splits, and keeping the ground truth for each. Extract every invoice into a strict Pydantic schema (vendor, GSTIN, line items, tax breakup, total) using the provider's structured-output mode. Add a validation layer that recomputes the tax arithmetic and flags any invoice where the splits and line totals do not reconcile with the stated total, and repair malformed model output with one corrective retry before failing loudly.
Start from
20 synthetic GST invoices you generate - a script varies vendor layout, GSTIN, HSN codes and CGST/SGST splits, and stores the ground truth for scoring
Milestones
- Write the generator that emits 20 varied invoices plus their ground truth · ~1.5h
- Define the Pydantic schema and get structured extraction running end to end · ~1.5h
- Add the tax-reconciliation validator and the malformed-output repair retry · ~1.5h
Done when
- Pydantic schema enforces types (GSTIN pattern, decimal amounts) and rejects invalid extractions
- At least 15 varied sample invoices (different formats/vendors) processed with over 90% field accuracy
- A validation check flags cases where CGST+SGST+line totals don't reconcile with the invoice total
- Malformed model output triggers one retry with an error-correction prompt before failing loudly
Prove it
Evidence a recruiter can check
- Field-level accuracy scored against the generator's ground truth across all 20 invoices
- The validator log catching an invoice whose CGST and SGST do not reconcile with its stated total
- The Pydantic schema itself, with the GSTIN pattern and decimal constraints that reject a bad extraction
- A malformed model response pasted next to the corrective retry that repaired it
Signal it
Built a schema-validated invoice extractor using structured outputs - Pydantic-enforced GSTIN and decimal types, a tax-reconciliation check that flags invoices whose splits do not add up, and a repair retry for malformed model output.
Interview
Questions you'll get asked
- How do you guarantee an LLM response is valid JSON your backend can parse without crashing?
- What's the difference between JSON mode, function calling, and Pydantic-based structured outputs?
- How do you handle a field the model hallucinates that isn't in your schema?
- Walk me through extracting structured data (amount, date, vendor) from a scanned invoice using an LLM.
- How would you validate and auto-correct a malformed LLM output in a production pipeline?
- How do you design a schema so the model doesn't have to guess formats (dates, currency) inconsistently?