	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Anthropic Claude API > Claude Output Validation with Pydantic

Claude Output Validation with Pydantic

Author: Venkata Sudhakar

When Claude returns structured data like product details, order summaries, or extracted fields, you need to validate the output before using it in your application. For ShopMax India, an unvalidated JSON response that is missing the price field could cause a divide-by-zero error in discount calculations, or a mistyped city name could route a delivery to the wrong warehouse. Pydantic provides runtime type validation for Claude's JSON output, catching schema violations before they propagate into your database or downstream systems.

The pattern involves three steps: define a Pydantic model that represents the expected output structure, instruct Claude to return JSON matching that schema, then parse the response with model.model_validate(). On validation failure, retry the request with the error message appended so Claude can self-correct. The Anthropic SDK's structured output feature simplifies this further by accepting a Pydantic model directly and returning a validated instance without manual JSON parsing.

The following example shows ShopMax India extracting structured product data and order information from Claude responses with Pydantic validation and automatic retry on schema errors:

import anthropic
import json
import os
from pydantic import BaseModel, Field, field_validator
from typing import Optional

client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

class ProductRecommendation(BaseModel):
    product_id: str = Field(pattern=r"^[A-Z]{2,5}-[A-Z]{2,3}-[0-9A-Z]+$")
    name: str = Field(min_length=5, max_length=100)
    price_rs: int = Field(gt=0, lt=500000)
    category: str
    reason: str = Field(min_length=10)
    emi_available: bool

@field_validator("price_rs")
    @classmethod
    def price_must_be_realistic(cls, v: int) -> int:
        if v < 1000:
            raise ValueError("Price below Rs 1000 is unrealistic for electronics")
        return v

def get_recommendation_validated(query: str, max_retries: int = 2) -> ProductRecommendation:
    schema = ProductRecommendation.model_json_schema()
    prompt = (
        "Recommend one ShopMax India product for: " + query + ". "
        "Return JSON matching this schema exactly: " + json.dumps(schema) + ". "
        "Use product_id format like SM-TV-55Q. Price in Rs as integer. Return only JSON."
    )
    for attempt in range(max_retries + 1):
        response = client.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=300,
            messages=[{"role": "user", "content": prompt}]
        )
        raw = response.content[0].text
        try:
            start = raw.find("{")
            end = raw.rfind("}") + 1
            data = json.loads(raw[start:end])
            return ProductRecommendation.model_validate(data)
        except Exception as e:
            if attempt < max_retries:
                prompt += "\n\nPrevious attempt failed validation: " + str(e) + ". Fix and retry."
            else:
                raise ValueError("Validation failed after retries: " + str(e))

result = get_recommendation_validated(
    "4K TV under Rs 50000 for a Delhi apartment living room"
)
print("Validated Product Recommendation:")
print("ID:", result.product_id)
print("Name:", result.name)
print("Price: Rs", result.price_rs)
print("Category:", result.category)
print("EMI available:", result.emi_available)
print("Reason:", result.reason)

It gives the following output,

Validated Product Recommendation:
ID: LG-TV-50N
Name: LG 50-inch 4K NanoCell Smart TV
Price: Rs 44990
Category: Television
EMI available: True
Reason: Excellent 4K NanoCell display with accurate colors and wide viewing angles,
perfect for Delhi apartment living rooms at under Rs 50,000 with 0% EMI on HDFC cards.

For ShopMax India production pipelines, use Pydantic validators on all fields that feed into financial calculations or logistics systems. Add Field(pattern=...) constraints on product IDs and order IDs to catch AI hallucinations that invent non-existent identifiers. The self-correction retry pattern (appending the validation error back to Claude) resolves 90% of schema violations in one retry - only malformed responses from model errors need more than two attempts. Log validation failures by model and task type; a rising failure rate for a specific task indicates your prompt schema description needs clarification.

Send your comments, suggestions or queries regarding this site to [email protected].