输出解析器与回调
学习使用解析器有效组织 LLM 输出，并使用回调监控和调试 LangChain 应用
输出解析器与回调 是 CoddyKit 上的免费 LangChain / RAG / Vector DBs 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 LangChain / RAG / Vector DBs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 LangChain / RAG / Vector DBs 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
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!
常见问题解答
「输出解析器与回调」课时是免费的吗？
是的 — 「输出解析器与回调」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 LangChain / RAG / Vector DBs 课程的其余内容，请升级到 CoddyKit PRO。 LangChain / RAG / Vector DBs 课程共包含 4 节课。
「输出解析器与回调」这节课中我会学到什么？
学习使用解析器有效组织 LLM 输出，并使用回调监控和调试 LangChain 应用 你通过在浏览器中直接运行的动手代码来练习 LangChain / RAG / Vector DBs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 LangChain / RAG / Vector DBs 需要有经验吗？
无需任何先前经验。CoddyKit 上的 LangChain / RAG / Vector DBs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「输出解析器与回调」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 LangChain / RAG / Vector DBs 课中编写并运行代码吗？
能。每节 LangChain / RAG / Vector DBs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。