Structured output with JSON schemas

pip install -U google-genai pydantic python-dotenv

from enum import Enum

from pydantic import BaseModel, Field


class ItemId(str, Enum):
    espresso = "espresso"
    cappuccino = "cappuccino"
    cold_brew = "cold-brew"
    filter_coffee = "filter-coffee"
    masala_chai = "masala-chai"
    croissant = "croissant"
    banana_bread = "banana-bread"
    veg_sandwich = "veg-sandwich"


class OrderLine(BaseModel):
    item_id: ItemId
    qty: int = Field(ge=1, le=20, description="How many of this item")


class ParsedOrder(BaseModel):
    customer_name: str | None = Field(
        default=None, description="Customer's name, or null if not mentioned"
    )
    items: list[OrderLine]
    pickup_time: str | None = Field(
        default=None, description="Pickup time as HH:MM in 24-hour format, or null"
    )
    unclear: list[str] = Field(
        default_factory=list,
        description="Anything the customer asked for that is not on the menu or is ambiguous",
    )

from dotenv import load_dotenv
from google import genai
from google.genai import types

from schema import ParsedOrder

load_dotenv()
MODEL = "gemini-flash-latest"  # use a current model ID
client = genai.Client()

MENU_NOTE = (
    "Menu: espresso, cappuccino, cold brew, filter coffee, masala chai, "
    "butter croissant, banana bread, veg grilled sandwich."
)


def parse_order(text: str) -> ParsedOrder:
    response = client.models.generate_content(
        model=MODEL,
        contents=text,
        config=types.GenerateContentConfig(
            system_instruction=(
                "You extract coffee shop orders from customer messages. "
                + MENU_NOTE
                + " Only use items from the menu. If the customer asks for something "
                "else, put it in `unclear`. Never guess a name or time."
            ),
            temperature=0,
            response_mime_type="application/json",
            response_schema=ParsedOrder,
        ),
    )
    # response.parsed is already a ParsedOrder object when a Pydantic class is used
    if response.parsed is None:
        raise ValueError("Model returned no valid JSON: " + str(response.text))
    return response.parsed


if __name__ == "__main__":
    order = parse_order("Hi, 2 cappuccinos and a croissant for 6:30pm, name is Ravi. Also a pizza.")
    print(order.model_dump_json(indent=2))

from datetime import datetime

from parse_order import parse_order


def check(order):
    problems = []
    if not order.items:
        problems.append("No valid items found")
    if order.pickup_time:
        try:
            datetime.strptime(order.pickup_time, "%H:%M")
        except ValueError:
            problems.append("Pickup time is not HH:MM")
    if order.unclear:
        problems.append("Needs follow-up: " + ", ".join(order.unclear))
    return problems


order = parse_order("one filter coffee please")
issues = check(order)
print("OK" if not issues else issues)

import { GoogleGenAI, Type } from "@google/genai";

const ai = new GoogleGenAI({});

const response = await ai.models.generateContent({
  model: "gemini-flash-latest", // use a current model ID
  contents: "Two masala chai for Meena at 5pm",
  config: {
    responseMimeType: "application/json",
    responseSchema: {
      type: Type.OBJECT,
      properties: {
        customer_name: { type: Type.STRING, nullable: true },
        items: {
          type: Type.ARRAY,
          items: {
            type: Type.OBJECT,
            properties: {
              item_id: { type: Type.STRING, enum: ["espresso", "masala-chai", "croissant"] },
              qty: { type: Type.INTEGER },
            },
            required: ["item_id", "qty"],
          },
        },
      },
      required: ["items"],
    },
  },
});

const order = JSON.parse(response.text);
console.log(order);

I am building [feature, e.g. a resume parser / support ticket classifier]. Design a Pydantic model (Python) for the structured output I should request from an LLM. Use enums for fixed choices, make uncertain fields optional, add a short description for every field, and list 5 test inputs, including 2 tricky ones where information is missing.