Parsing Model Output Demo 1

In this lesson we explore output parsers and how they convert free-text responses from large language models into structured Python data. Output parsers make it simple to enforce predictable formats (CSV, JSON, lists) so downstream code can consume model outputs reliably.

The image shows the interface of a Jupyter Notebook, displaying an empty code cell ready for input. The toolbar and menu options are visible at the top.

This lesson assumes your OpenAI API key is already configured in your environment.

Quick overview

Goal: Instruct an LLM to return a comma-separated list and parse it into a native Python list.
Approach: Append parser-provided format_instructions to the prompt so the model emits a predictable format, then use the parser to convert the text to Python objects.

1. Imports and basic prompt setup

Import the required classes, create an LLM client, and define a simple prompt template.

from langchain.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain.output_parsers import CommaSeparatedListOutputParser

llm = OpenAI()
prompt = PromptTemplate(
    template="List 3 {things}",
    input_variables=["things"]
)

2. Invoke the model with a simple prompt (raw output)

Call the LLM without any parser instructions to see the default textual output.

raw = llm.invoke(input=prompt.format(things="countries that play cricket in world cup"))
print(raw)

Example raw output (string)

India
Australia
England

This raw response is a plain string with numbered lines. To use it programmatically you’d typically write manual parsing logic (strip numbering, split lines). Output parsers automate this process.

3. Add a CommaSeparatedListOutputParser and get format instructions

The CommaSeparatedListOutputParser provides human-readable instructions that you append to your prompt. These instructions encourage the LLM to produce CSV-style output that can be parsed reliably.

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

Format instructions printed:

Your response should be a list of comma separated values, eg: `foo, bar, baz`

4. Inject the format instructions into the prompt

Use partial_variables in PromptTemplate to include the parser’s format_instructions in the prompt. This keeps your prompt template flexible and reusable.

prompt = PromptTemplate(
    template="List 3 {things}.\n{format_instructions}",
    input_variables=["things"],
    partial_variables={"format_instructions": format_instructions}
)

final_prompt = prompt.format(things="countries that play cricket in world cup")
print(final_prompt)

The constructed final_prompt will look like:

List 3 countries that play cricket in world cup.
Your response should be a list of comma separated values, eg: `foo, bar, baz`

Tip: Using partial_variables lets you add dynamic instructions (like format hints) without changing the main prompt template every time.

5. Invoke the model with the parser-aware prompt and parse the output

Now the model is instructed to return CSV-style text. After receiving the text, feed it to output_parser.parse() to get a Python list.

output = llm.invoke(input=final_prompt)
print(output.strip())       # e.g., "India, Australia, England"
print(type(output))         # <class 'str'>

things = output_parser.parse(output)
print(things)               # ['India', 'Australia', 'England']
print(type(things))         # <class 'list'>
print(things[0])            # 'India'

Example console outputs:

India, Australia, England
<class 'str'>
['India', 'Australia', 'England']
<class 'list'>
India

Summary

Append parser format_instructions to your prompt to guide the model toward a predictable output format (CSV in this example).
Use CommaSeparatedListOutputParser to transform the returned string into a native Python list.
This pattern reduces brittle string processing and improves data reliability when integrating LLM responses into applications.

Quick reference table

Component	Purpose	Example
`PromptTemplate`	Reusable prompt structure with variables	`PromptTemplate(template="List 3 {things}.\n{format_instructions}", ...)`
`OpenAI()`	LLM client / runtime	`llm = OpenAI()`
`CommaSeparatedListOutputParser`	Instructs and parses CSV-like outputs into `list`	`things = output_parser.parse(output)`

Next steps

Try other output parsers (for example, JSON-specific parsers) if you need objects/dictionaries directly from the model.
Combine parser format instructions with few-shot examples when you need stronger conditioning.
Validate parsed outputs before using them in production systems to handle cases where the model doesn’t follow instructions exactly.

Links and references

LLMs may sometimes ignore formatting instructions. Always validate parser output and add fallback handling for unexpected 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 1

Quick overview

1. Imports and basic prompt setup

2. Invoke the model with a simple prompt (raw output)

3. Add a CommaSeparatedListOutputParser and get format instructions

4. Inject the format instructions into the prompt

5. Invoke the model with the parser-aware prompt and parse the output

Summary

Quick reference table

Next steps

Links and references

Watch Video

​Quick overview

​1. Imports and basic prompt setup

​2. Invoke the model with a simple prompt (raw output)

​3. Add a CommaSeparatedListOutputParser and get format instructions

​4. Inject the format instructions into the prompt

​5. Invoke the model with the parser-aware prompt and parse the output

​Summary

​Quick reference table

​Next steps

​Links and references

Watch Video

Quick overview

1. Imports and basic prompt setup

2. Invoke the model with a simple prompt (raw output)

3. Add a CommaSeparatedListOutputParser and get format instructions

4. Inject the format instructions into the prompt

5. Invoke the model with the parser-aware prompt and parse the output

Summary

Quick reference table

Next steps

Links and references