Streamline Your AI: Mastering OpenAI Structured Outputs for Enhanced Performance

Are you struggling to get consistent, reliable responses from OpenAI's models? Do you need AI outputs that seamlessly integrate with your applications? Then it’s time to harness the power of structured outputs.

Structured outputs guarantee that the model will always generate responses conforming to your supplied JSON schema. Think of it as a foolproof way to ensure your AI speaks your application's language.

Why Use Structured Outputs? The Concrete Benefits

• Consistent Data: Get predictable, structured data every time, simplifying parsing and integration into your existing systems.
• Robust Applications: Build more stable, production-ready applications because you can rely on your defined schema.
• Simplified UI Integration: Display data in a specific format in your user interface.
• Effortless Database Population: Extract content from documents and automatically populate your databases with structured information.

Response Format or Function Calls: Getting Started with Structured Outputs

Structured outputs are enabled by setting strict: true in your API call alongside a defined response format or function definitions. You essentially tell the model: "Follow this blueprint, no exceptions."

Response Format Usage

You can specify the exact JSON schema you expect the model to adhere to.

Function Call Usage

Function calling remains similar, but with strict: true, the schema defined for the functions must be followed.

Real-World Structured Outputs Examples: See it in Action

The versatility of structured outputs shines through in various applications:

• AI-Powered Math Tutor: Generate step-by-step solutions to math problems in a structured array, perfectly for displaying each step individually.
• Automated Summarization: Instantly transform articles into structured objects, ideal for populating databases or displaying information concisely.
• Smart Product Recommendations: Use function calling to extract user preferences and search for matching products, creating a seamless e-commerce experience.

Code Example: Math Tutor with Structured Outputs (Response Format)

This code snippet shows how to create a math tutor that provides step-by-step solutions conforming to a rigid JSON schema.

import json
from textwrap import dedent
from openai import OpenAI
client = OpenAI()

MODEL="gpt-4o-2024-08-06"

math_tutor_prompt ='''
 You are a helpful math tutor. You will be provided with a math problem,
 and your goal will be to output a step by step solution, along with a final answer.
 For each step, just provide the output as an equation use the explanation field to detail the reasoning.
'''

def get_math_solution(question):
    response = client.chat.completions.create(
        model=MODEL,
        messages=[
            {
                "role": "system",
                "content": dedent(math_tutor_prompt)
            },
            {
                "role": "user",
                "content": question
            }
        ],
        response_format={
            "type": "json_schema",
            "json_schema": {
                "type": "object",
                "properties": {
                    "steps": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "explanation": {"type": "string"},
                                "output": {"type": "string"}
                            },
                            "required": ["explanation", "output"],
                            "additionalProperties": False
                        }
                    },
                    "final_answer": {"type": "string"}
                },
                "required": ["steps", "final_answer"],
                "additionalProperties": False
            },
            "strict": True
        }
    )

    return response.choices[0].message

# Example usage
question = "how can I solve 8x + 7 = -23"
result = get_math_solution(question)
print(result.content)

This example defines a JSON schema for the steps and the final answer, ensuring that the response always adheres to this structure.

Streamlining with the SDK parse Helper

The OpenAI SDK offers a parse helper, allowing you to define a Pydantic model instead of directly defining a JSON schema. This approach is generally more readable and maintainable.

from pydantic import BaseModel

class MathReasoning(BaseModel):
    class Step(BaseModel):
        explanation: str
        output: str

    steps: list[Step]
    final_answer: str

def get_math_solution(question: str):
    completion = client.beta.chat.completions.parse(
        model=MODEL,
        messages=[
            {"role": "system", "content": dedent(math_tutor_prompt)},
            {"role": "user", "content": question},
        ],
        response_format=MathReasoning,
    )

    return completion.choices[0].message

Handling Refusals

When dealing with user-generated input, the model may refuse to answer for safety reasons. The API provides a refusal field to indicate such instances, preventing errors and allowing for graceful handling in your UI.

Long-Tail Keyword Focus: Structured Output and AI Automation

This article highlights the use of structured outputs for tasks such as building an AI-powered math tutor, or for AI automation, with the goal to streamline response formats with the correct JSON schema for a variety of use cases.

Take Control of Your AI Today

Structured outputs are more than just a feature; they represent a fundamental shift towards reliable, predictable AI. By embracing this powerful capability, you can build robust applications, streamline data integration, and unlock new possibilities with OpenAI's models. Start experimenting with structured outputs today and experience the difference.