LangChain with_structured_output() — schema validation and method errors

from typing import List, Literal
from pydantic import BaseModel, Field
from langchain_openai import ChatOpenAI

class ExtractedInfo(BaseModel):
    """Information extracted from the input text."""
    name: str = Field(description="The person's full name")
    role: str = Field(description="Their job title or role")
    company: str = Field(description="The company they work at")
    years_experience: int = Field(
        default=0,
        description="Years of experience mentioned; 0 if not mentioned"
    )
    skills: List[str] = Field(
        default_factory=list,
        description="Technical skills mentioned"
    )
    confidence: Literal["low", "medium", "high"] = Field(
        default="medium",
        description="Your confidence in the extracted information"
    )

llm = ChatOpenAI(model="gpt-4o-mini")

# For OpenAI 4o+, json_schema is best (strict mode)
structured_llm = llm.with_structured_output(ExtractedInfo, method="json_schema", strict=True)

result = structured_llm.invoke(
    "Alice Johnson has been a Senior ML Engineer at TechCorp for 5 years. "
    "She specializes in NLP and computer vision."
)
print(result)
# ExtractedInfo(name='Alice Johnson', role='Senior ML Engineer',
#               company='TechCorp', years_experience=5,
#               skills=['NLP', 'computer vision'], confidence='high')

# Access as an object
print(result.name)
print(result.skills)

from pydantic import BaseModel, Field
from typing import List

class Recipe(BaseModel):
    name: str = Field(description="Recipe name")
    ingredients: List[str] = Field(description="Ingredient list")
    steps: List[str] = Field(description="Cooking steps in order")

# --- OpenAI 4o+ / o1: json_schema with strict is strongest ---
from langchain_openai import ChatOpenAI
openai_llm = ChatOpenAI(model="gpt-4o-mini").with_structured_output(
    Recipe, method="json_schema", strict=True
)

# --- Anthropic Claude: function_calling ---
from langchain_anthropic import ChatAnthropic
claude_llm = ChatAnthropic(model="claude-sonnet-5").with_structured_output(
    Recipe, method="function_calling"
)

# --- Google Gemini: function_calling ---
from langchain_google_genai import ChatGoogleGenerativeAI
gemini_llm = ChatGoogleGenerativeAI(model="gemini-2.5-pro").with_structured_output(
    Recipe, method="function_calling"
)

# --- Ollama / open-source: json_mode (weakest but broadest) ---
from langchain_ollama import ChatOllama
ollama_llm = ChatOllama(model="llama3.1:8b").with_structured_output(
    Recipe, method="json_mode"
)

# All four accept the same invoke and return a Recipe object
for name, llm in [("openai", openai_llm), ("claude", claude_llm),
                  ("gemini", gemini_llm), ("ollama", ollama_llm)]:
    try:
        recipe = llm.invoke("How to make pancakes?")
        print(f"{name}: {recipe.name} — {len(recipe.ingredients)} ingredients")
    except Exception as e:
        print(f"{name}: ERROR {e}")

# For debugging: include_raw returns both the parsed model AND the raw AIMessage
structured_llm_debug = openai_llm.with_structured_output(
    Recipe, method="json_schema", include_raw=True
)
result = structured_llm_debug.invoke("...")
# result = {"raw": AIMessage(...), "parsed": Recipe(...), "parsing_error": None or Exception}

# ❌ Too complex — deep nesting and Union
# from typing import Union
# class Address(BaseModel): ...
# class Person(BaseModel):
#     name: str
#     contact: Union[EmailContact, PhoneContact, PostalContact]
#     history: List[Union[Employment, Education, Certification]]

# ✓ Flatter — discriminated types
from typing import List, Literal, Optional
from pydantic import BaseModel, Field

class ContactMethod(BaseModel):
    kind: Literal["email", "phone", "postal"] = Field(description="Contact type")
    value: str = Field(description="Contact value as a string")

class HistoryItem(BaseModel):
    kind: Literal["employment", "education", "certification"]
    title: str = Field(description="Position, degree, or certification name")
    organization: str = Field(description="Company, school, or issuer")
    start_year: int
    end_year: int = Field(description="0 if ongoing")

class Person(BaseModel):
    name: str = Field(description="Full name")
    contacts: List[ContactMethod] = Field(default_factory=list)
    history: List[HistoryItem] = Field(default_factory=list)

# For debugging schemas, print the JSON schema
import json
print(json.dumps(Person.model_json_schema(), indent=2))
# Verify: no circular refs, no unions the provider rejects, all fields have descriptions

# For validation failures, use include_raw
structured_llm_debug = ChatOpenAI(model="gpt-4o-mini").with_structured_output(
    Person, method="json_schema", strict=True, include_raw=True
)

result = structured_llm_debug.invoke("Some text about a person...")

if result["parsing_error"]:
    print(f"Parse error: {result['parsing_error']}")
    print(f"Raw output was: {result['raw'].content}")
else:
    person = result["parsed"]