Callbacks

All right — we are now at the third demo where

The image is a slide with the word "Demo" on the left and "Callbacks" on a blue gradient shape on the right.

In this lesson we’ll explain what callbacks are in LangChain, why they matter for observability and production systems, and how to use built-in and custom handlers to capture lifecycle events from chains and LLM calls.

Minimal LangChain example

This minimal program creates an LLM chain that formats a prompt and invokes an LLM:

from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain

llm = ChatOpenAI()
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a {subject} teacher"),
        ("human", "Tell me about {concept}")
    ]
)
chain = LLMChain(llm=llm, prompt=prompt)

chain.invoke({"subject": "physics", "concept": "galaxy"})

A typical result returned by the chain might look like this (JSON-style):

{
  "subject": "physics",
  "concept": "galaxy",
  "text": "A galaxy is a vast system of stars, gas, dust, and dark matter bound together by gravity. It is the basic building block of the universe, containing billions to trillions of stars, as well as planets, nebulae, and other celestial objects.\n\nGalaxies come in different shapes and sizes, including spiral, elliptical, and irregular types. Our Milky Way is a spiral galaxy that contains hundreds of billions of stars. Galaxies often group into clusters and provide important clues about the structure and evolution of the universe."
}

What are callbacks and why use them?

A callback is a function or handler that the LangChain runtime invokes at specific lifecycle events — for example when a prompt is formatted, when an LLM call starts or ends, when a chain begins or finishes, or when tools are invoked. Callbacks allow you to:

Record runtime events (console, files, or structured logs).
Route events to observability systems (Datadog, Splunk, CloudWatch, etc.).
Transform or post-process outputs (HTML, structured JSON).
Aggregate metrics and implement custom telemetry.
Debug and trace execution across chains and tools.

Example uses:

Print LLM/chains events to stdout while developing.
Save inputs/outputs into structured logs for later analysis.
Emit metrics for latency, token usage, or error rates.

Built-in stdout handler example

This example imports and uses the built-in StdOutCallbackHandler to print lifecycle messages to the console. Note how we pass the handler via the callbacks parameter to the chain.

from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.callbacks.stdout import StdOutCallbackHandler

# Create the handler and the chain
handler = StdOutCallbackHandler()

llm = ChatOpenAI()
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a {subject} teacher"),
        ("human", "Tell me about {concept}")
    ]
)
chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler])

# Invoke the chain
chain.invoke({"subject": "physics", "concept": "galaxy"})

When you run this, the stdout handler prints debug-like lifecycle messages to standard output. Example console output (truncated for brevity):

> Entering new LLMChain chain...
Prompt after formatting:
System: You are a physics teacher
Human: Tell me about galaxy

> Finished chain.
{
  "subject": "physics",
  "concept": "galaxy",
  "text": "A galaxy is a massive, gravitationally bound system that consists of stars, gas, dust, and dark matter. Galaxies come in various shapes and sizes, ranging from small dwarf galaxies to large spiral and elliptical galaxies. Our own Milky Way is a spiral galaxy that contains billions of stars."
}

Key differences and control points

Use the right mechanism depending on environment and goals. The table below summarizes the options and when to use them.

Option	When to use	Example / Notes
Global debug	Quick development-time debugging	Enables global verbose output; simple but harder to route (`debug=True`)
Component-level `verbose`	Inspect a specific component without changing global behavior	Use `verbose=True` on the component: `LLMChain(..., verbose=True)`
Callback handlers (recommended)	Production telemetry, structured logs, and routing to observability backends	Pass handlers via `callbacks=[handler]`. Use built-in handlers (e.g., `StdOutCallbackHandler`) or custom handlers to emit JSON, metrics, or push to external services.

Example combining verbose and callbacks:

chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler], verbose=True)
chain.invoke({"subject": "physics", "concept": "galaxy"})

Creating custom handlers when you need more control

For production use cases you’ll often want to implement a custom callback handler to format events, emit structured JSON, or push telemetry to a remote service. The handler receives lifecycle events and can perform any custom action required by your app. Skeleton example (implement the methods you need):

from langchain.callbacks.base import BaseCallbackHandler

class MyLoggingHandler(BaseCallbackHandler):
    def on_chain_start(self, serialized, inputs, **kwargs):
        # Called when a chain starts
        print("chain started", inputs)

    def on_chain_end(self, outputs, **kwargs):
        # Called when a chain finishes
        # You can format outputs, write to files, or push to a logging backend
        print("chain finished", outputs)

    def on_llm_start(self, serialized, prompts, **kwargs):
        # Called when an LLM call starts
        pass

    def on_llm_end(self, response, **kwargs):
        # Called when the LLM call ends
        pass

Integrate your handler by passing it to the chain:

handler = MyLoggingHandler()
chain = LLMChain(llm=llm, prompt=prompt, callbacks=[handler])

Best practices

Use callback handlers for production logging, metrics, and observability.
Keep stdout handlers for local development or CI debugging.
Implement only the callback methods you need to minimize overhead.
Ensure sensitive data (API keys, PII) is redacted before sending logs to third-party systems.
Combine verbose on specific components with callbacks to get granular insight without overwhelming global logging.

Callbacks are a flexible and powerful mechanism for observability and production-grade telemetry. Prefer callback handlers over global debug for routing structured logs, metrics, or formatted outputs to external systems.

Summary

Callbacks are invoked at key lifecycle events during chain execution.
StdOutCallbackHandler is useful for quick, readable runtime output to the console.
For production use, implement or reuse custom handlers to send structured logs, metrics, or trace data to files or cloud services.
Combine component verbose flags with callbacks for targeted, flexible observability.

Links and references

Later, we’ll walk through additional resources and practical examples to build production-grade LangChain applications.

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

Minimal LangChain example

What are callbacks and why use them?

Built-in stdout handler example

Key differences and control points

Creating custom handlers when you need more control

Best practices

Summary

Links and references

Watch Video

​Minimal LangChain example

​What are callbacks and why use them?

​Built-in stdout handler example

​Key differences and control points

​Creating custom handlers when you need more control

​Best practices

​Summary

​Links and references

Watch Video

Minimal LangChain example

What are callbacks and why use them?

Built-in stdout handler example

Key differences and control points

Creating custom handlers when you need more control

Best practices

Summary

Links and references