Parsing Model Output Demo 2

In this lesson we generate LLM output and reliably transform it into JSON using an output parser. You’ll learn how to:

Call a language model to list countries and capitals.
Instruct the model to return valid JSON using a JsonOutputParser’s format instructions.
Parse the LLM response into native Python data structures for direct use in application logic.

Quick links and references:

1) Imports and a simple LLM call

Start by importing the necessary components and creating an LLM client:

from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.output_parsers import JsonOutputParser
import json

llm = OpenAI()

Construct a straightforward prompt template and call the model to get an unconstrained textual answer (a plain list):

prompt = PromptTemplate(
    template="List 3 countries in {continent} and their capitals",
    input_variables=["continent"],
)

# Call the LLM (returns a string)
raw_output = llm(prompt.format(continent="Asia"))
print(raw_output)

Example typical output:

Japan - Tokyo
China - Beijing
India - New Delhi

This output is human-readable but not structured. To work with it programmatically, we need to guide the model to emit JSON.

2) Add a JsonOutputParser and obtain format instructions

Instantiate a JsonOutputParser to provide the LLM with exact format instructions. The parser exposes a helper string you can embed in your prompt to ask for valid JSON:

output_parser = JsonOutputParser()
format_instructions = output_parser.get_format_instructions()
print(format_instructions)

The printed format_instructions will be a short guideline such as “Return a JSON object.” Use this text so the model knows to produce valid, parseable JSON.

3) Create a prompt that includes the format instructions

Embed the parser’s instructions into your prompt using partial_variables. This ensures every invocation contains the necessary instructions for structured output:

prompt = PromptTemplate(
    template="List 3 countries in {continent} and their capitals\n{format_instructions}",
    input_variables=["continent"],
    partial_variables={"format_instructions": format_instructions},
)

Inspect the prompt to confirm the instructions are included:

print(prompt.format(continent="North America"))

Example rendered prompt:

List 3 countries in North America and their capitals
Return a JSON object.

4) Invoke the LLM with the structured prompt and parse the result

Call the model with the new prompt and then parse the returned JSON string into native Python types:

response = llm(prompt.format(continent="North America"))
print(response)

Example model output (valid JSON):

{
  "USA": "Washington D.C.",
  "Canada": "Ottawa",
  "Mexico": "Mexico City"
}

Now parse the JSON string into Python:

countries = output_parser.parse(response)  # Parses string -> Python dict/list depending on JSON
print(type(countries))   # -> <class 'dict'>
print(json.dumps(countries))  # Serializes back to a JSON string if needed

Example console output:

<class 'dict'>
{"USA": "Washington D.C.", "Canada": "Ottawa", "Mexico": "Mexico City"}

5) Why this approach helps

The parser’s format instructions encourage the LLM to produce valid JSON (or another predictable format), reducing parsing errors.
Passing the LLM response through JsonOutputParser converts a string into native Python types (dict, list), which eliminates manual parsing and validation plumbing.
Once parsed, the result can be fed directly into application logic, converted into dataclasses, or serialized for storage/transmission.

Quick reference: workflow steps

Step	Purpose	Example/Command
1	Define prompt template	`PromptTemplate(template="List 3 countries in {continent} and their capitals", input_variables=["continent"])`
2	Create LLM client	`llm = OpenAI()`
3	Instantiate parser	`output_parser = JsonOutputParser()`
4	Embed format instructions	Use `format_instructions = output_parser.get_format_instructions()` and `partial_variables`
5	Call LLM and parse	`response = llm(prompt.format(...))` then `countries = output_parser.parse(response)`

Links and further reading

Always include the parser’s format instructions in the prompt when you want structured output; otherwise the model may return freeform text that fails to parse.

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 2

1) Imports and a simple LLM call

2) Add a JsonOutputParser and obtain format instructions

3) Create a prompt that includes the format instructions

4) Invoke the LLM with the structured prompt and parse the result

5) Why this approach helps

Quick reference: workflow steps

Links and further reading

Watch Video

​1) Imports and a simple LLM call

​2) Add a JsonOutputParser and obtain format instructions

​3) Create a prompt that includes the format instructions

​4) Invoke the LLM with the structured prompt and parse the result

​5) Why this approach helps

​Quick reference: workflow steps

​Links and further reading

Watch Video

1) Imports and a simple LLM call

2) Add a JsonOutputParser and obtain format instructions

3) Create a prompt that includes the format instructions

4) Invoke the LLM with the structured prompt and parse the result

5) Why this approach helps

Quick reference: workflow steps

Links and further reading