with_structured_output

The output schema. Can be passed in as:

• An OpenAI function/tool schema,
• A JSON Schema,
• A TypedDict class,
• Or a Pydantic class.

If schema is a Pydantic class then the model output will be a Pydantic instance of that class, and the model-generated fields will be validated by the Pydantic class. Otherwise the model output will be a dict and will not be validated.

See langchain_core.utils.function_calling.convert_to_openai_tool for more on how to properly specify types and descriptions of schema fields when specifying a Pydantic or TypedDict class.

The method for steering model generation, one of:

• 'function_calling': Uses OpenAI's tool-calling API (formerly called function calling)
• 'json_schema': Uses OpenAI's Structured Output API
• 'json_mode': Uses OpenAI's JSON mode. Note that if using JSON mode then you must include instructions for formatting the output into the desired schema into the model call

If False then only the parsed structured output is returned.

If an error occurs during model output parsing it will be raised.

If True then both the raw model response (a BaseMessage) and the parsed model response will be returned.

If an error occurs during output parsing it will be caught and returned as well.

The final output is always a dict with keys 'raw', 'parsed', and 'parsing_error'.

• True: Model output is guaranteed to exactly match the schema. The input schema will also be validated according to the supported schemas.
• False: Input schema will not be validated and model output will not be validated.
• None: strict argument will not be passed to the model.

A list of tool-like objects to bind to the chat model. Requires that:

• method is 'json_schema' (default).
• strict=True
• include_raw=True

If a model elects to call a tool, the resulting AIMessage in 'raw' will include tool calls.

from langchain.chat_models import init_chat_model
from pydantic import BaseModel

class ResponseSchema(BaseModel):
    response: str

def get_weather(location: str) -> str:
    """Get weather at a location."""
    pass

model = init_chat_model("openai:gpt-4o-mini")

structured_model = model.with_structured_output(
    ResponseSchema,
    tools=[get_weather],
    strict=True,
    include_raw=True,
)

structured_model.invoke("What's the weather in Boston?")

{
    "raw": AIMessage(content="", tool_calls=[...], ...),
    "parsing_error": None,
    "parsed": None,
}

Additional keyword args are passed through to the model.