Analizadores de salida y callbacks
Aprenda a estructurar eficazmente las salidas de los LLM mediante analizadores y a utilizar callbacks para supervisar y depurar sus aplicaciones de LangChain.
Analizadores de salida y callbacks es una lección gratuita de LangChain / RAG / Vector DBs en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de LangChain / RAG / Vector DBs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de LangChain / RAG / Vector DBs incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
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!
Preguntas frecuentes
¿La lección «Analizadores de salida y callbacks» es gratis?
Sí — el texto completo de «Analizadores de salida y callbacks» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de LangChain / RAG / Vector DBs, actualiza a CoddyKit PRO. El curso de LangChain / RAG / Vector DBs incluye 4 lecciones en total.
¿Qué aprenderé en «Analizadores de salida y callbacks»?
Aprenda a estructurar eficazmente las salidas de los LLM mediante analizadores y a utilizar callbacks para supervisar y depurar sus aplicaciones de LangChain. Practicas LangChain / RAG / Vector DBs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar LangChain / RAG / Vector DBs?
No se requiere experiencia previa. LangChain / RAG / Vector DBs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Analizadores de salida y callbacks»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de LangChain / RAG / Vector DBs?
Sí. Cada lección de LangChain / RAG / Vector DBs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Configuración de su entorno LangChain
- Prompts, LLM y cadenas básicas
- Analizadores de salida y callbacks
- Memoria y contexto conversacional en LangChain