Output Parsers

def parse(self, text: str) -> T

def parse_result(
    self,
    result: list[Generation],
    *,
    partial: bool = False
) -> T

async def aparse(self, text: str) -> T

async def aparse_result(
    self,
    result: list[Generation],
    *,
    partial: bool = False
) -> T

def invoke(
    self,
    input: str | BaseMessage,
    config: RunnableConfig | None = None,
    **kwargs: Any
) -> T

def get_format_instructions(self) -> str

def parse_result(
    self,
    result: list[Generation],
    *,
    partial: bool = False
) -> Any

def parse(self, text: str) -> Any

from langchain_core.output_parsers import JsonOutputParser
from langchain_core.prompts import PromptTemplate
from pydantic import BaseModel, Field

class Joke(BaseModel):
    setup: str = Field(description="The setup of the joke")
    punchline: str = Field(description="The punchline")

parser = JsonOutputParser(pydantic_object=Joke)

prompt = PromptTemplate(
    template="Tell me a joke.\n{format_instructions}",
    input_variables=[],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)

chain = prompt | model | parser
result = chain.invoke({})  # {"setup": "...", "punchline": "..."}

def __init__(self, pydantic_object: type[TBaseModel])

def parse(self, text: str) -> TBaseModel

from langchain_core.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field

class Person(BaseModel):
    name: str = Field(description="Person's name")
    age: int = Field(description="Person's age")

parser = PydanticOutputParser(pydantic_object=Person)

chain = prompt | model | parser
result = chain.invoke({...})  # Person(name="...", age=...)

def parse(self, text: str) -> str

from langchain_core.output_parsers import StrOutputParser

chain = prompt | model | StrOutputParser()
result = chain.invoke({...})  # "string output"

def parse(self, text: str) -> list[str]

from langchain_core.output_parsers import CommaSeparatedListOutputParser

parser = CommaSeparatedListOutputParser()
parser.parse("apple, banana, orange")  # ["apple", "banana", "orange"]

def parse(self, text: str) -> dict

from langchain_core.output_parsers import XMLOutputParser

parser = XMLOutputParser()
parser.parse(
    "<person><name>John</name><age>30</age></person>"
)
# {"person": {"name": "John", "age": "30"}}

def parse_result(
    self,
    result: list[Generation],
    *,
    partial: bool = False
) -> list[dict[str, Any]]

from langchain_core.output_parsers.openai_tools import JsonOutputKeyToolsParser

parser = JsonOutputKeyToolsParser(key_name="search", first_tool_only=True)

chain = model.bind_tools([search_tool]) | parser
result = chain.invoke("search for cats")  # {"query": "cats"}

from langchain_core.output_parsers.openai_tools import PydanticToolsParser
from pydantic import BaseModel, Field

class SearchArgs(BaseModel):
    query: str = Field(description="Search query")

parser = PydanticToolsParser(tools=[SearchArgs], first_tool_only=True)

chain = model.bind_tools([SearchArgs]) | parser
result = chain.invoke("search for cats")  # SearchArgs(query="cats")

def transform(
    self,
    input: Iterator[str | BaseMessage],
    config: RunnableConfig | None = None,
    **kwargs: Any
) -> Iterator[T]

async def atransform(
    self,
    input: AsyncIterator[str | BaseMessage],
    config: RunnableConfig | None = None,
    **kwargs: Any
) -> AsyncIterator[T]