Pengurai Keluaran dan Callback

Unstructured LLM Outputs

What are Output Parsers?

Parsing Lists: CommaSeparatedListOutputParser

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

PydanticOutputParser in Action

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

Basic Monitoring: StdOutCallbackHandler

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

Output Parsers & Callbacks Check

Lesson Summary