Output Parsers and Callbacks
Learn to structure LLM outputs effectively using parsers and use callbacks to monitor and debug your LangChain applications.
Output Parsers and Callbacks is a free LangChain / RAG / Vector DBs lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the LangChain / RAG / Vector DBs learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Unstructured LLM Outputs
Large Language Models (LLMs) are amazing, but their raw text outputs can often be messy and inconsistent. Imagine asking an LLM for a list of items, and sometimes it gives you a comma-separated string, other times a bullet list, or even a full paragraph!
This lack of structure makes it hard for your applications to reliably process and use the information. How can we make LLMs deliver predictable data?
What are Output Parsers?
Output Parsers are tools in LangChain designed to convert the unstructured, free-form text responses from LLMs into a structured, usable format.
They act as a bridge, transforming raw text into Python objects like lists, dictionaries, or Pydantic models. This ensures your application always receives data in the expected shape, making your code more robust and easier to manage.
Parsing Lists: CommaSeparatedListOutputParser
One of the simplest output parsers is the CommaSeparatedListOutputParser. It's perfect when you expect the LLM to return a list of items separated by commas.
LangChain will automatically inject instructions into your prompt, guiding the LLM to produce output in the correct format. Try running this example:
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import CommaSeparatedListOutputParser
# Mock LLM for demonstration without actual API calls
class MockLLM:
def invoke(self, prompt, config=None):
if "list 3 programming languages" in prompt:
return "Python, Java, C++"
return "Default response"
def main():
parser = CommaSeparatedListOutputParser()
prompt = PromptTemplate(
template="List 3 programming languages.\n{format_instructions}",
input_variables=[],
partial_variables={
"format_instructions": parser.get_format_instructions()
},
)
llm = MockLLM() # In a real app, replace with ChatOpenAI, etc.
chain = prompt | llm | parser
result = chain.invoke({})
print(f"Parsed result: {result}")
print(f"Type: {type(result)}")
if __name__ == "__main__":
main()Structured Output with Pydantic
For more complex data, like extracting a person's name, age, and city, LangChain integrates beautifully with Pydantic. Pydantic allows you to define data schemas using Python classes with type hints.
The PydanticOutputParser uses your Pydantic model to generate detailed instructions for the LLM, guiding it to output a JSON string that perfectly matches your desired structure.
PydanticOutputParser in Action
Here, we define a Person Pydantic model. The parser then ensures the LLM's output can be directly converted into an instance of this class, giving you strongly typed, structured data.
Notice how the parser.get_format_instructions() guides the LLM.
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field
# Mock LLM for demonstration
class MockLLM:
def invoke(self, prompt, config=None):
if "extract information about a person" in prompt:
# LLM would output JSON matching Pydantic schema
return '{"name": "Alice", "age": 30, "city": "New York"}'
return "Default response"
class Person(BaseModel):
name: str = Field(description="The person's name")
age: int = Field(description="The person's age")
city: str = Field(description="The city the person lives in")
def main():
parser = PydanticOutputParser(pydantic_object=Person)
prompt = PromptTemplate(
template="Extract information about a person from the text 'Alice is 30 years old and lives in New York'.\n{format_instructions}",
input_variables=[],
partial_variables={
"format_instructions": parser.get_format_instructions()
},
)
llm = MockLLM() # In a real app, replace with ChatOpenAI, etc.
chain = prompt | llm | parser
result = chain.invoke({})
print(f"Parsed result: {result}")
print(f"Type: {type(result)}")
print(f"Name: {result.name}, Age: {result.age}")
if __name__ == "__main__":
main()Monitoring with Callbacks
Beyond just getting structured output, you often need to understand what's happening *inside* your LangChain application. This is where Callbacks come in.
Callbacks allow you to hook into various events that occur during a chain's execution, such as when an LLM call starts or ends, when a tool is used, or when a chain completes.
- Logging: See detailed steps.
- Debugging: Pinpoint issues quickly.
- Monitoring: Track performance and usage.
- Streaming: Display intermediate LLM thoughts.
Basic Monitoring: StdOutCallbackHandler
LangChain provides several built-in callback handlers. The StdOutCallbackHandler is a great starting point, as it simply prints all significant events directly to your console.
This gives you a real-time view of the chain's execution flow, including LLM inputs, outputs, and any errors. Add it to your chain's configuration:
from langchain.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain.callbacks import StdOutCallbackHandler
from langchain_core.runnables import RunnablePassthrough
from langchain_core.messages import AIMessage, HumanMessage
# Mock Chat Model for demonstration purposes
class MockChatModel:
def invoke(self, messages, config=None):
callbacks = config.get("callbacks", []) if config else []
# Extract input text from messages
input_text = ""
if isinstance(messages, list) and messages:
input_text = messages[0].content if isinstance(messages[0], HumanMessage) else str(messages[0])
else:
input_text = str(messages)
# Simulate on_llm_start event
for handler in callbacks:
if hasattr(handler, 'on_llm_start'):
handler.on_llm_start({"name": "MockChatModel"}, [input_text])
# Simulate LLM processing and response
response_content = f"Mock response for: '{input_text[:50]}...'"
# Simulate on_llm_end event
for handler in callbacks:
if hasattr(handler, 'on_llm_end'):
handler.on_llm_end(response_content)
return AIMessage(content=response_content)
def main():
handler = StdOutCallbackHandler()
llm = MockChatModel() # Replace with actual LLM like ChatOpenAI
prompt = PromptTemplate.from_template("Tell me a short fact about {topic}.")
chain = (
{"topic": RunnablePassthrough()} # Input for the prompt
| prompt
| llm
| StrOutputParser()
)
print("--- Running chain with StdOutCallbackHandler ---")
# Pass the handler to the chain's invoke method via config
result = chain.invoke("Python programming language", config={"callbacks": [handler]})
print(f"\nFinal Result: {result}")
if __name__ == "__main__":
main()Customizing Callbacks
For advanced scenarios, you can create your own custom callback handlers. By inheriting from BaseCallbackHandler, you can override specific methods to react to events exactly how you need.
This allows for highly tailored logging, integrating with external monitoring systems, or building interactive UI elements that update in real-time. Key methods to override include:
on_llm_start: Before an LLM call.on_chain_end: After a chain finishes.on_tool_start: Before an agent uses a tool.on_agent_action: When an agent decides on an action.
Output Parsers & Callbacks Check
Output Parsers and Callbacks are fundamental for building robust, observable, and reliable LangChain applications. Let's test your understanding.
Lesson Summary
Great job! Today, you've mastered two essential LangChain concepts:
- Output Parsers: These tools bring order to LLM responses, transforming unstructured text into predictable Python objects like lists or Pydantic models. They are crucial for making your LLM applications reliable.
- Callbacks: You learned how callbacks provide deep insights into your chain's execution. They are invaluable for logging, debugging, monitoring, and even streaming real-time updates from your LangChain applications.
These building blocks are vital for creating sophisticated and observable LLM-powered solutions!
Frequently asked questions
Is the “Output Parsers and Callbacks” lesson free?
Yes — the full text of “Output Parsers and Callbacks” is free to read here on the web, and the LangChain / RAG / Vector DBs course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the LangChain / RAG / Vector DBs course, upgrade to CoddyKit PRO.
What will I learn in “Output Parsers and Callbacks”?
Learn to structure LLM outputs effectively using parsers and use callbacks to monitor and debug your LangChain applications. You practise LangChain / RAG / Vector DBs with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start LangChain / RAG / Vector DBs?
No prior experience is required. LangChain / RAG / Vector DBs on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Output Parsers and Callbacks” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this LangChain / RAG / Vector DBs lesson?
Yes. Every LangChain / RAG / Vector DBs lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.