Parsing Model Output Demo 3

In this lesson you’ll learn how to use a Pydantic-based output parser to convert LLM responses into a typed Python object. Using Pydantic (via LangChain utilities), you declare a schema with Python type annotations and then validate/parse JSON-like model output into instances of that schema—giving you robust guarantees about structure and types when working with LLM-generated data. Key concepts covered:

Defining a Pydantic model for the expected response.
Creating a PydanticOutputParser.
Embedding parser format instructions in the prompt so the LLM returns JSON matching the schema.
Invoking the model and parsing the output into a typed Python object.

Complete example

Below is a concise, runnable example showing the full workflow: define a model, create a parser, add format instructions to the prompt, call the model, and parse the response.

# imports
from typing import List

from langchain_openai import OpenAI
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain.prompts import PromptTemplate
from langchain.output_parsers import PydanticOutputParser

# initialize model
model = OpenAI()

# define the Pydantic model for a ticket reservation
class Ticket(BaseModel):
    date: str = Field(description="show date")
    time: str = Field(description="show time")
    theater: str = Field(description="theater name")
    count: int = Field(description="number of tickets")
    movie: str = Field(description="preferred movie")

# create the Pydantic output parser
parser = PydanticOutputParser(pydantic_object=Ticket)

# prompt template with placeholders for the movie query and parser format instructions
ticket_template = '''
Book us a movie ticket for two this Friday at 6:00 PM.
Choose any theater, it doesn't matter. Send the confirmation by email.
Our preferred movie is: {query}
Format instructions:
{format_instructions}
'''

prompt = PromptTemplate(
    template=ticket_template,
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

This example shows how the parser provides format_instructions (a JSON Schema-like specification). Including these instructions in your prompt guides the LLM to emit well-formed JSON that the parser can validate and load into a Pydantic model.

Notes on imports and model invocation

Import paths and how you call the model can differ between LangChain versions and wrappers. Common variations:

from langchain import OpenAI vs from langchain_openai import OpenAI
BaseModel and Field may come directly from pydantic
Model invocation can use model.invoke(...), model.predict(...), or model(...) depending on the wrapper

Be sure to consult your installed LangChain / OpenAI wrapper docs if you hit import or invocation errors.

Build the final prompt

Supply a movie name (for example, Interstellar) and render the prompt. The format_instructions partial will contain the JSON Schema-like instructions the model should follow.

input = prompt.format_prompt(query="Interstellar")
print(input.to_string())

The embedded format instructions will look similar to this excerpt (JSON Schema-like):

{
  "properties": {
    "date": { "title": "Date", "description": "show date", "type": "string" },
    "time": { "title": "Time", "description": "show time", "type": "string" },
    "theater": { "title": "Theater", "description": "theater name", "type": "string" },
    "count": { "title": "Count", "description": "number of tickets", "type": "integer" },
    "movie": { "title": "Movie", "description": "preferred movie", "type": "string" }
  },
  "required": ["date", "time", "theater", "count", "movie"]
}

Invoke the model and parse the response

Call the model with the formatted prompt string and capture the output:

output = model.invoke(input.to_string())

A typical LLM response (the exact wrapper text depends on the model) containing JSON might be:

{
  "date": "Friday",
  "time": "6:00 PM",
  "theater": "AMC",
  "count": 2,
  "movie": "Interstellar"
}

Pass the model output through the PydanticOutputParser to convert it into a typed Ticket instance:

reservation = parser.parse(output)
print(reservation)
print(type(reservation))

Example parser output:

Ticket(date='Friday', time='6:00 PM', theater='AMC', count=2, movie='Interstellar')
<class '__main__.Ticket'>

Field reference

Field	Type	Description	Example
`date`	`string`	Show date	`Friday`
`time`	`string`	Show time	`6:00 PM`
`theater`	`string`	Theater name	`AMC`
`count`	`integer`	Number of tickets	`2`
`movie`	`string`	Preferred movie	`Interstellar`

Why this pattern is useful

You get strong guarantees about the shape and types of the data your application receives from an LLM.
Parsing into a Pydantic model makes downstream processing, validation, and IDE/autocomplete support straightforward.
Embedding parser.get_format_instructions() in the prompt aligns the LLM output to the schema, reducing parsing errors.

The parser validates and converts JSON to an instance of the Ticket model. If the model’s output does not conform to the schema, the parser will raise a validation error—so including format_instructions in the prompt is important to guide the LLM toward valid output.

Summary

Steps to follow:

Define a Pydantic model (subclass of BaseModel) describing the expected fields and types.
Create a PydanticOutputParser using that Pydantic model.
Include parser.get_format_instructions() as a partial variable in your prompt template.
Invoke the LLM with the formatted prompt.
Use parser.parse(...) to convert the model output into a typed Python object.

This approach makes it straightforward to work with LLM-generated data in a type-safe way and reduces runtime errors caused by unexpected response formats.

Introduction

Overview of LangChain

Key Components of LangChain

Interacting with LLMs

Tips, Tricks, and Resources

Introduction to LCEL

Adding Memory to LLM Apps

Performing Retrieval

Implementing Chains

Using Tools

Building Agents

Conclusion

Building Blocks of LLM Apps

Parsing Model Output Demo 3

Complete example

Notes on imports and model invocation

Build the final prompt

Invoke the model and parse the response

Field reference

Why this pattern is useful

Summary

Links and references

Watch Video

Practice Lab

​Complete example

​Notes on imports and model invocation

​Build the final prompt

​Invoke the model and parse the response

​Field reference

​Why this pattern is useful

​Summary

​Links and references

Watch Video

Practice Lab

Complete example

Notes on imports and model invocation

Build the final prompt

Invoke the model and parse the response

Field reference

Why this pattern is useful

Summary

Links and references