Get clean object-based responses from LLMs with LangChain

Have you ever felt the frustration of getting an LLM response that’s almost what you need, but still requires a lot of manual work to transform it into something usable? You’re not alone. We’ve all been in a situation where you ask a language model a question, and it spits out a string of text. It looks promising, but the real work is just beginning. You have to manually parse that text, extract the relevant information, and then shape it into a format that your application can understand. It’s a tedious and error-prone process, especially when dealing with complex queries or multiple responses.

If you’ve tried using JSON prompts, you might think you’ve found a solution. While JSON provides a structured format, it’s still a string that needs to be parsed into usable objects. It’s better than raw text, but it’s far from ideal. Wouldn’t it be great if you could get direct, structured responses from your LLM?

Imagine receiving Python objects — dictionaries, lists, or custom classes — straight from your language model, ready to be used in your application. No more string manipulation, no more parsing headaches. With LangChain’s with_structured_output, this is now possible. In this blog, I'll show you how to use with_structured_output to simplify your workflow and eliminate the need for manual parsing. You'll be able to focus on building better applications, faster.

What is with_structured_output ?

At its core, with_structured_output is a feature in LangChain that allows you to receive structured data directly from your LLM as objects. Instead of the typical string-based responses, which often require extra parsing and manipulation, LangChain’s with_structured_output ensures that the data comes back in a usable, object-based format—without you having to write additional code.

In simple terms, with_structured_output transforms LLM responses from raw text into structured objects (such as dictionaries, lists, or custom classes). This means you don’t need to write additional code to convert the output into something meaningful. The data is ready for use right out of the box.

For example, let’s say you’re building an application that needs to extract certain fields like a person’s name, age, and address.

Without with_structured_output :

You might get a string response that you have to parse manually and convert it into something structured, like a dictionary or a class instance.

# The LLM return a string that needs parsing
llm_response = "Name: John, Age: 25, Address: 123 Main St"

With with_structured_output :

When using with_structured_output, the LLM returns the data directly as an instance of a Person class, like so:\

# The LLM will return a Person object directly:
llm_response = Person(name="John", age=25, address="123 Main St")

Why its better than JSON response?

Many developers use JSON prompts to structure LLM responses. For instance, they might ask the model to return output in a specific JSON format by including an example in the prompt. While this approach works, it has some major limitations:

1. Parsing hassles: JSON outputs are still strings. You need to parse them into Python objects (e.g., dictionaries or classes) before they can be used, adding extra steps and complexity.
2. Error-prone: LLMs may occasionally generate invalid JSON due to their probabilistic nature. Missing commas, unmatched brackets, or malformed structures can break your parsing code.
3. Inconsistent keys: Without strict enforcement, the keys in JSON outputs might vary slightly (e.g., first_name vs. firstname), leading to errors in your application.

LangChain’s with_structured_output takes JSON prompts to the next level. Instead of generating raw strings, it uses Python’s native class structure to ensure that the output is returned as valid objects, eliminating the need for manual parsing or validation.

Here’s why LangChain’s with_structured_output is a game-changer:

• Direct object output: The LLM directly returns an object (e.g., an instance of a class like Person), ready to use. No parsing required.
• Error-free: You avoid issues with malformed JSON. The structure is predefined, and the LLM adheres to it.
• Easier debugging: (read more..)