Çıktı Ayrıştırıcıları ve Geri Çağırmalar
Ayrıştırıcıları kullanarak LLM çıktılarını etkili biçimde yapılandırmayı, LangChain uygulamalarınızı izlemek ve hatalarını ayıklamak için geri çağırmaları kullanmayı öğrenin.
Çıktı Ayrıştırıcıları ve Geri Çağırmalar, CoddyKit'te ücretsiz bir LangChain / RAG / Vector DBs dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, LangChain / RAG / Vector DBs öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. LangChain / RAG / Vector DBs kursu toplamda 4 dersten oluşur.
Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.
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!
Sıkça Sorulan Sorular
“Çıktı Ayrıştırıcıları ve Geri Çağırmalar” dersi ücretsiz mi?
Evet — “Çıktı Ayrıştırıcıları ve Geri Çağırmalar” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve LangChain / RAG / Vector DBs kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. LangChain / RAG / Vector DBs kursu toplamda 4 dersten oluşur.
“Çıktı Ayrıştırıcıları ve Geri Çağırmalar” dersinde ne öğreneceğim?
Ayrıştırıcıları kullanarak LLM çıktılarını etkili biçimde yapılandırmayı, LangChain uygulamalarınızı izlemek ve hatalarını ayıklamak için geri çağırmaları kullanmayı öğrenin. LangChain / RAG / Vector DBs ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.
LangChain / RAG / Vector DBs öğrenmeye başlamak için deneyim gerekli mi?
Önceden deneyim gerekmez. CoddyKit'te LangChain / RAG / Vector DBs, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.
“Çıktı Ayrıştırıcıları ve Geri Çağırmalar” dersi ne kadar sürer?
Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.
Bu LangChain / RAG / Vector DBs dersinde kod yazıp çalıştırabilir miyim?
Evet. Her LangChain / RAG / Vector DBs dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.
Bu kursun tüm dersleri
- LangChain Ortamınızı Kurma
- İstemler, LLM'ler ve Temel Zincirler
- Çıktı Ayrıştırıcıları ve Geri Çağırmalar
- LangChain'de Bellek ve Konuşma Bağlamı