create_structured_output_chain() — langchain Function Reference

Source Code

libs/langchain/langchain_classic/chains/openai_functions/base.py lines 149–239

def create_structured_output_chain(
    output_schema: dict[str, Any] | type[BaseModel],
    llm: BaseLanguageModel,
    prompt: BasePromptTemplate,
    *,
    output_key: str = "function",
    output_parser: BaseLLMOutputParser | None = None,
    **kwargs: Any,
) -> LLMChain:
    """[Legacy] Create an LLMChain that uses an OpenAI function to get a structured output.

    Args:
        output_schema: Either a dictionary or pydantic.BaseModel class. If a dictionary
            is passed in, it's assumed to already be a valid JsonSchema.
            For best results, pydantic.BaseModels should have docstrings describing what
            the schema represents and descriptions for the parameters.
        llm: Language model to use, assumed to support the OpenAI function-calling API.
        prompt: BasePromptTemplate to pass to the model.
        output_key: The key to use when returning the output in LLMChain.__call__.
        output_parser: BaseLLMOutputParser to use for parsing model outputs. By default
            will be inferred from the function types. If pydantic.BaseModels are passed
            in, then the OutputParser will try to parse outputs using those. Otherwise
            model outputs will simply be parsed as JSON.
        **kwargs: Additional keyword arguments to pass to LLMChain.

    Returns:
        An LLMChain that will pass the given function to the model.

    Example:
        ```python
        from typing import Optional

        from langchain_classic.chains.openai_functions import create_structured_output_chain
        from langchain_openai import ChatOpenAI
        from langchain_core.prompts import ChatPromptTemplate

        from pydantic import BaseModel, Field

        class Dog(BaseModel):
            \"\"\"Identifying information about a dog.\"\"\"

            name: str = Field(..., description="The dog's name")
            color: str = Field(..., description="The dog's color")
            fav_food: str | None = Field(None, description="The dog's favorite food")

        model = ChatOpenAI(model="gpt-3.5-turbo-0613", temperature=0)
        prompt = ChatPromptTemplate.from_messages(
            [
                ("system", "You are a world class algorithm for extracting information in structured formats."),
                ("human", "Use the given format to extract information from the following input: {input}"),
                ("human", "Tip: Make sure to answer in the correct format"),
            ]
        )
        chain = create_structured_output_chain(Dog, model, prompt)
        chain.run("Harry was a chubby brown beagle who loved chicken")
        # -> Dog(name="Harry", color="brown", fav_food="chicken")

        ```
    """  # noqa: E501
    if isinstance(output_schema, dict):
        function: Any = {
            "name": "output_formatter",
            "description": (
                "Output formatter. Should always be used to format your response to the"
                " user."
            ),
            "parameters": output_schema,
        }
    else:

        class _OutputFormatter(BaseModel):
            """Output formatter.

            Should always be used to format your response to the user.
            """

            output: output_schema  # type: ignore[valid-type]

        function = _OutputFormatter
        output_parser = output_parser or PydanticAttrOutputFunctionsParser(
            pydantic_schema=_OutputFormatter,