getting structured outputs using openai functions

[rohitgr7]

hey folks!
langchain has these functions to extract structured outputs

create_extraction_chain_pydantic
create_structured_output_chain

both of them call openai functions at the end

my questions are:

1. what's the difference in these two?
2. why does create_extraction_chain_pydantic always need to return an array? is there a function that gives only one structured output?
3. why does create_structured_output_chain have this weird formatting for function calls: why is it done this way?

[
    {
        "name": "_OutputFormatter",
        "description": "Output formatter. Should always be used to format your response to the user.",
        "parameters": {
            "title": "_OutputFormatter",
            "description": "Output formatter. Should always be used to format your response to the user.",
            "type": "object",
            "properties": {
                "output": {
                    ... actual function definition
                }
            },
            "required": [
                "output"
            ]
        }
    }
]

thanks :)

[dosubot[bot]]

🤖

Hello!

Let's go through your questions one by one:

1. The create_extraction_chain_pydantic and create_structured_output_chain functions in LangChain both serve to structure the output of language models, but they do so in slightly different ways.

   The create_extraction_chain_pydantic function is used to create a chain that extracts information from a passage using a Pydantic schema. It takes in a Pydantic schema, a language model, a prompt, and a verbosity flag. The function then creates a chain that can be used to extract information from a passage based on the provided Pydantic schema. You can find more details about this function in the extraction.py file.

   On the other hand, the create_structured_output_chain function is used to create a chain that forces the model to return a particular kind of structured output. This function takes in a desired structured output (either a Pydantic class or a JsonSchema), a language model, a prompt, and a verbosity flag. You can find more details about this function in the qa_with_structure.py file.

2. The create_extraction_chain_pydantic function always returns an array because it's designed to extract multiple instances of a given schema from a passage. If you want to extract only one instance, you can simply take the first element of the returned array. If you want a function that always returns a single instance, you might need to create a custom function or modify the existing one.

3. The specific formatting for function calls in create_structured_output_chain is due to the way OpenAI functions are structured. Each function is represented as a dictionary with a "name", "description", and "parameters". The "parameters" field is another dictionary that describes the input parameters of the function. This structure allows for a clear and consistent way to define and call functions.

I hope this helps! Let me know if you have any other questions.

Sources

• libs/langchain/langchain/chains/openai_functions/extraction.py
• libs/langchain/langchain/chains/openai_functions/qa_with_structure.py
• docs/docs/modules/chains/how_to/openai_functions.ipynb
• docs/extras/modules/chains/how_to/openai_functions.ipynb

---

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[rohitgr7]

ended up writing my custom version:

from typing import Type

from langchain.chains import LLMChain
from langchain.chains.openai_functions import create_openai_fn_chain
from langchain.output_parsers.openai_functions import PydanticOutputFunctionsParser
from langchain.pydantic_v1 import BaseModel


def create_structured_output_chain_custom(
    output_schema: Type[BaseModel],
    llm,
    prompt,
    *,
    output_key: str = "function",
    output_parser=None,
    **kwargs,
) -> LLMChain:
    output_parser = output_parser or PydanticOutputFunctionsParser(pydantic_schema=output_schema)
    return create_openai_fn_chain(
        [output_schema],
        llm,
        prompt,
        output_key=output_key,
        output_parser=output_parser,
        **kwargs,
    )