Structured Output in LangChain

Structured Output in LangChain allows an LLM to return data in a predefined structure instead of returning only free-form text. It is especially useful when you want to connect an LLM with APIs, databases, RAG applications, AI agents, and frontend applications.

What is Structured Output in LangChain? #

Normally, Large Language Models (LLMs) return natural language responses. For example:

Rahul is 25 years old and works as a Python Developer.

This response is easy for a human to understand, but it is not always convenient for a Python application to process.

With structured output, we can define exactly what information we want:

{
    "name": "Rahul",
    "age": 25,
    "job": "Python Developer"
}

In LangChain, we can define this structure using a schema such as a Pydantic model and then use with_structured_output().

Why Do We Need Structured Output? #

LLMs are designed to generate text, while software applications usually need predictable and machine-readable data.

For example, suppose we are building a resume parser. We may need:

• Name
• Email
• Skills
• Education
• Experience

Without structured output, the LLM might return a paragraph:

Rahul Kumar is a Python Developer.
His email is [email protected].
He has experience with Python, Django and SQL.

Our application would then need additional logic to extract each value.

With structured output, we can directly get:

{
    "name": "Rahul Kumar",
    "email": "[email protected]",
    "skills": ["Python", "Django", "SQL"]
}

Now the application can easily access individual values.

Normal LLM Output vs Structured Output #

Normal LLM Output #

User Input
    ↓
LLM
    ↓
Free-form Text
    ↓
Manual Parsing

Structured Output #

User Input
    ↓
LLM
    ↓
Defined Schema
    ↓
Structured Data
    ↓
Application

This makes structured output much more useful when an LLM is part of a larger software system.

How to Use Structured Output in LangChain? #

One of the simplest approaches is to use a Pydantic model as the output schema.

Step 1: Import Pydantic #

from pydantic import BaseModel, Field

Step 2: Create a Schema #

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

Here we have defined three fields:

• name → String
• age → Integer
• job → String

Step 3: Create the LLM #

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-5.4"
)

The model name should be changed according to the model and provider you are using.

Step 4: Add Structured Output #

structured_llm = llm.with_structured_output(Person)

This is the most important line.

It tells LangChain that we want the model’s response to follow the Person schema.

Step 5: Invoke the Model #

result = structured_llm.invoke(
    "Rahul is 25 years old and works as a Python Developer."
)

print(result)

The result will look similar to:

Person(
    name="Rahul",
    age=25,
    job="Python Developer"
)

Access Individual Values #

Because the result is a Pydantic object, we can access individual fields directly.

print(result.name)
print(result.age)
print(result.job)

Output:

Rahul
25
Python Developer

Complete Structured Output Example #

Here is the complete example:

from pydantic import BaseModel, Field
from langchain_openai import ChatOpenAI


# Define output schema
class Person(BaseModel):
    name: str = Field(
        description="Person's name"
    )

    age: int = Field(
        description="Person's age"
    )

    job: str = Field(
        description="Person's profession"
    )


# Create LLM
llm = ChatOpenAI(
    model="gpt-5.4"
)


# Add structured output
structured_llm = llm.with_structured_output(Person)


# Invoke model
result = structured_llm.invoke(
    "Rahul is 25 years old and works as a Python Developer."
)


# Print complete result
print(result)


# Access individual fields
print("Name:", result.name)
print("Age:", result.age)
print("Job:", result.job)

Structured Output with Lists #

Structured output can also contain lists. For example, we can create a schema for a student’s skills:

from pydantic import BaseModel


class Student(BaseModel):
    name: str
    age: int
    skills: list[str]

The model can return:

Student(
    name="Rahul",
    age=25,
    skills=[
        "Python",
        "SQL",
        "Machine Learning",
        "FastAPI"
    ]
)

Structured Output with Nested Objects #

We can also create nested schemas.

from pydantic import BaseModel


class Address(BaseModel):
    city: str
    country: str


class Person(BaseModel):
    name: str
    age: int
    address: Address

For example, the output can be:

Person(
    name="Rahul",
    age=25,
    address=Address(
        city="Patna",
        country="India"
    )
)

Real-World Example: Resume Parser #

One of the practical applications of structured output is extracting information from resumes.

from pydantic import BaseModel, Field


class Resume(BaseModel):
    name: str = Field(
        description="Candidate's full name"
    )

    email: str = Field(
        description="Candidate's email address"
    )

    skills: list[str] = Field(
        description="Candidate's technical skills"
    )

    experience_years: float = Field(
        description="Years of professional experience"
    )

We can then create a structured LLM:

structured_llm = llm.with_structured_output(Resume)

Suppose the input resume contains:

Rahul Kumar
Python Developer
Email: [email protected]

Skills:
Python, Django, FastAPI, SQL, Machine Learning

Experience:
2 years

The LLM can return structured information such as:

Resume(
    name="Rahul Kumar",
    email="[email protected]",
    skills=[
        "Python",
        "Django",
        "FastAPI",
        "SQL",
        "Machine Learning"
    ],
    experience_years=2
)

This information can then be stored in a database or passed to another part of the application.

Structured Output in RAG Applications #

Structured output is also useful in Retrieval-Augmented Generation (RAG). For example, instead of returning only an answer, we can define:

class Answer(BaseModel):
    answer: str
    confidence: float
    sources: list[str]

The application can then receive:

Answer(
    answer="Python is a programming language.",
    confidence=0.95,
    sources=["document_1"]
)

The frontend can display the answer, confidence, and sources separately.

Structured Output vs Asking the LLM for JSON #

A common beginner approach is to simply tell the LLM:

Return the answer in JSON format.

Although this can work, it does not provide the same level of schema control as using structured output.

Prompt-Based JSON #

LLM
 ↓
"Return JSON"
 ↓
Text that looks like JSON
 ↓
JSON Parser

Structured Output #

LLM
 ↓
Defined Schema
 ↓
Structured Response
 ↓
Application

Structured output is therefore a better approach when your application requires predictable data.

Structured Output vs Tool Calling #

Structured output and tool calling are related, but they have different purposes.

Tool Calling #

Tool calling allows an LLM to request that a function or tool be executed.

LLM
 ↓
Tool Call
 ↓
get_weather("Patna")
 ↓
Weather Result

Structured Output #

Structured output is primarily about returning data in a predefined schema.

LLM
 ↓
Schema
 ↓
Structured Data

Depending on the model and provider, LangChain can use provider-native structured output or tool/function calling to achieve structured results.

Where is Structured Output Used? #

• Resume parsing
• Information extraction
• RAG applications
• AI agents
• Customer support systems
• Job recommendation systems
• Sentiment analysis
• Document processing
• FastAPI and other APIs
• Database applications
• AI dashboards
• Frontend applications

Key Method to Remember #

If you are learning LangChain, remember this basic pattern:

from pydantic import BaseModel
from langchain_openai import ChatOpenAI


class Person(BaseModel):
    name: str
    age: int
    job: str


llm = ChatOpenAI(model="gpt-5.4")

structured_llm = llm.with_structured_output(Person)

result = structured_llm.invoke(
    "Rahul is 25 years old and works as a Python Developer."
)

print(result)

Summary #

Structured Output in LangChain allows an LLM to return predictable, schema-defined data instead of only free-form text.

The basic workflow is:

Define Schema
     ↓
Create LLM
     ↓
with_structured_output()
     ↓
Invoke LLM
     ↓
Receive Structured Data

The most important method to remember is:

llm.with_structured_output(Schema)

Structured output becomes especially valuable when an LLM is connected to real software systems such as APIs, databases, RAG pipelines, recommendation systems, and AI agents.

Frequently Asked Questions #

What is Structured Output in LangChain? #

Structured Output allows an LLM to return information according to a predefined schema rather than returning only free-form text.

Why use Structured Output? #

It makes LLM responses easier for applications to validate, process, store, and pass to other components.

What is the main method for Structured Output? #

The main method for direct LangChain model calls is with_structured_output().

Can Pydantic be used with Structured Output? #

Yes. Pydantic is a common choice for defining structured-output schemas in Python LangChain applications.

Is Structured Output the same as JSON? #

No. JSON is a data format, while structured output is a mechanism for obtaining model responses that conform to a defined schema. The resulting data may be represented as a Pydantic object or dictionary depending on the schema and approach used.