Toggle Menu
Prev Up Next

# `langchain.chains.structured_output.base`.create_openai_fn_runnable

langchain.chains.structured_output.base.create_openai_fn_runnable(functions: Sequence[Union[Dict[str, Any], Type[BaseModel], Callable]], llm: Runnable, prompt: Optional[BasePromptTemplate] = None, *, enforce_single_function_usage: bool = True, output_parser: Optional[Union[BaseOutputParser, BaseGenerationOutputParser]] = None, **llm_kwargs: Any) → Runnable

  [Deprecated] Create a runnable sequence that uses OpenAI functions.

  Parameters

    - functions (Sequence[Union[Dict[str, Any], Type[BaseModel], Callable]]) – A sequence of either dictionaries, pydantic.BaseModels classes, or Python functions. If dictionaries are passed in, they are assumed to already be a valid OpenAI functions. If only a single function is passed in, then it will be enforced that the model use that function. pydantic.BaseModels and Python functions should have docstrings describing what the function does. For best results, pydantic.BaseModels should have descriptions of the parameters and Python functions should have Google Python style args descriptions in the docstring. Additionally, Python functions should only use primitive types (str, int, float, bool) or pydantic.BaseModels for arguments.

    - llm (Runnable) – Language model to use, assumed to support the OpenAI function-calling API.

    - prompt (Optional[BasePromptTemplate]) – BasePromptTemplate to pass to the model.

    - enforce_single_function_usage (bool) – only used if a single function is passed in. If True, then the model will be forced to use the given function. If False, then the model will be given the option to use the given function or not.

    - output_parser (Optional[Union[BaseOutputParser, BaseGenerationOutputParser]]) – 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. If multiple functions are passed in and they are not pydantic.BaseModels, the chain output will include both the name of the function that was returned and the arguments to pass to the function.

    - **llm_kwargs (Any) – Additional named arguments to pass to the language model.

  Returns

    A runnable sequence that will pass in the given functions to the model when run.

  Return type

    Runnable

  Example

      from typing import Optional

      from langchain.chains.structured_output import create_openai_fn_runnable
      from langchain_openai import ChatOpenAI
      from langchain_core.pydantic_v1 import BaseModel, Field

      class RecordPerson(BaseModel):
          '''Record some identifying information about a person.'''

          name: str = Field(..., description="The person's name")
          age: int = Field(..., description="The person's age")
          fav_food: Optional[str] = Field(None, description="The person's favorite food")

      class RecordDog(BaseModel):
          '''Record some identifying information about a dog.'''

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

      llm = ChatOpenAI(model="gpt-4", temperature=0)
      structured_llm = create_openai_fn_runnable([RecordPerson, RecordDog], llm)
      structured_llm.invoke("Harry was a chubby brown beagle who loved chicken)
      # -> RecordDog(name="Harry", color="brown", fav_food="chicken")

  Notes

  Deprecated since version 0.1.14: LangChain has introduced a method called with_structured_output that is available on ChatModels capable of tool calling. You can read more about the method here: https://python.langchain.com/docs/modules/model_io/chat/structured_output/ Please follow our extraction use case documentation for more guidelines on how to do information extraction with LLMs. https://python.langchain.com/docs/use_cases/extraction/. If you notice other issues, please provide feedback here: https://github.com/langchain-ai/langchain/discussions/18154 Use from langchain_core.pydantic_v1 import BaseModel, Field from langchain_anthropic import ChatAnthropic

  > class Joke(BaseModel):

  >   setup: str = Field(description=”The setup of the joke”) punchline: str = Field(description=”The punchline to the joke”)

  > # Or any other chat model that supports tools. # Please reference to to the documentation of structured_output # to see an up to date list of which models support # with_structured_output. model = ChatAnthropic(model=”claude-3-opus-20240229”, temperature=0) structured_llm = model.with_structured_output(Joke) structured_llm.invoke(“Tell me a joke about cats.

  > > > Make sure to call the Joke function.”)

  > > instead.