Strukturierte Ausgaben

Erste Schritte

pip install openai pydantic azure-identity --upgrade

from pydantic import BaseModel
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=token_provider,
)

class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]

completion = client.beta.chat.completions.parse(
    model="MODEL_DEPLOYMENT_NAME", # replace with the model deployment name of your gpt-4o 2024-08-06 deployment
    messages=[
        {"role": "system", "content": "Extract the event information."},
        {"role": "user", "content": "Alice and Bob are going to a science fair on Friday."},
    ],
    response_format=CalendarEvent,
)

event = completion.choices[0].message.parsed

print(event)
print(completion.model_dump_json(indent=2))

name='Science Fair' date='Friday' participants=['Alice', 'Bob']
{
  "id": "chatcmpl-A1EUP2fAmL4SeB1lVMinwM7I2vcqG",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "message": {
        "content": "{\n  \"name\": \"Science Fair\",\n  \"date\": \"Friday\",\n  \"participants\": [\"Alice\", \"Bob\"]\n}",
        "refusal": null,
        "role": "assistant",
        "function_call": null,
        "tool_calls": [],
        "parsed": {
          "name": "Science Fair",
          "date": "Friday",
          "participants": [
            "Alice",
            "Bob"
          ]
        }
      }
    }
  ],
  "created": 1724857389,
  "model": "gpt-4o-2024-08-06",
  "object": "chat.completion",
  "service_tier": null,
  "system_fingerprint": "fp_1c2eaec9fe",
  "usage": {
    "completion_tokens": 27,
    "prompt_tokens": 32,
    "total_tokens": 59
  }
}

pip install openai pydantic --upgrade

import os
from pydantic import BaseModel
from openai import OpenAI

client = OpenAI(
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=os.getenv("AZURE_OPENAI_API_KEY")  
)

class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]

completion = client.beta.chat.completions.parse(
    model="MODEL_DEPLOYMENT_NAME", # replace with the model deployment name of your gpt-4o 2024-08-06 deployment
    messages=[
        {"role": "system", "content": "Extract the event information."},
        {"role": "user", "content": "Alice and Bob are going to a science fair on Friday."},
    ],
    response_format=CalendarEvent,
)

event = completion.choices[0].message.parsed

print(event)
print(completion.model_dump_json(indent=2))

name='Science Fair' date='Friday' participants=['Alice', 'Bob']
{
  "id": "chatcmpl-A1EUP2fAmL4SeB1lVMinwM7I2vcqG",
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "message": {
        "content": "{\n  \"name\": \"Science Fair\",\n  \"date\": \"Friday\",\n  \"participants\": [\"Alice\", \"Bob\"]\n}",
        "refusal": null,
        "role": "assistant",
        "function_call": null,
        "tool_calls": [],
        "parsed": {
          "name": "Science Fair",
          "date": "Friday",
          "participants": [
            "Alice",
            "Bob"
          ]
        }
      }
    }
  ],
  "created": 1724857389,
  "model": "gpt-4o-2024-08-06",
  "object": "chat.completion",
  "service_tier": null,
  "system_fingerprint": "fp_1c2eaec9fe",
  "usage": {
    "completion_tokens": 27,
    "prompt_tokens": 32,
    "total_tokens": 59
  }
}

Verwenden Sie strukturierte Ausgaben mit der Responses API

Verwenden Sie für die Responses API OpenAI Python 2.x und übergeben Sie ein Pydantic-Modell mithilfe des Parameters text_format an responses.parse. Das SDK konvertiert das Modell in ein JSON-Schema unter text.format und gibt den analysierten Wert in output_parsed.

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI
from pydantic import BaseModel

# Configure access.
endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/"
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)
openai = OpenAI(base_url=endpoint, api_key=token_provider)

# Define the structured response.
class CalendarEvent(BaseModel):
    name: str
    date: str
    participants: list[str]

# Parse the response directly into the Pydantic model.
response = openai.responses.parse(
    model="gpt-5-mini",
  input="Extract the event information from: Alice and Bob are going to a science fair on Friday.",
    text_format=CalendarEvent,
)

print(response.output_parsed)

Ausgabe:

name='Science Fair' date='Friday' participants=['Alice', 'Bob']

Funktionsaufrufe mit strukturierten Ausgaben

Strukturierte Ausgaben für Funktionsaufrufe können mit einem einzelnen Parameter aktiviert werden, indem strict: true bereitgestellt wird.

import openai
from pydantic import BaseModel
from openai import OpenAI
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://ai.azure.com/.default"
)

client = OpenAI(  
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=token_provider,
)

class GetDeliveryDate(BaseModel):
    order_id: str

tools = [openai.pydantic_function_tool(GetDeliveryDate)]

messages = []
messages.append({"role": "system", "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user."})
messages.append({"role": "user", "content": "Hi, can you tell me the delivery date for my order #12345?"}) 

response = client.chat.completions.create(
    model="MODEL_DEPLOYMENT_NAME", # replace with the model deployment name of your gpt-4o 2024-08-06 deployment
    messages=messages,
    tools=tools
)

print(response.choices[0].message.tool_calls[0].function)
print(response.model_dump_json(indent=2))

import os
from pydantic import BaseModel
import openai
from openai import OpenAI

client = OpenAI(
  base_url = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/",  
  api_key=os.getenv("AZURE_OPENAI_API_KEY")  
)

class GetDeliveryDate(BaseModel):
    order_id: str

tools = [openai.pydantic_function_tool(GetDeliveryDate)]

messages = []
messages.append({"role": "system", "content": "You are a helpful customer support assistant. Use the supplied tools to assist the user."})
messages.append({"role": "user", "content": "Hi, can you tell me the delivery date for my order #12345?"}) 

response = client.chat.completions.create(
    model="MODEL_DEPLOYMENT_NAME", # replace with the model deployment name of your gpt-4o 2024-08-06 deployment
    messages=messages,
    tools=tools
)

print(response.choices[0].message.tool_calls[0].function)
print(response.model_dump_json(indent=2))

Erste Schritte

Fügen Sie ihrem Projekt die folgenden Pakete hinzu:

• OpenAI: Standard OpenAI .NET Library.
• Azure. Identity: Stellt Microsoft Entra ID Unterstützung für die Tokenauthentifizierung in den Azure SDK-Bibliotheken bereit.

dotnet add package OpenAI
dotnet add package Azure.Identity

using Azure.Identity;
using OpenAI;
using OpenAI.Chat;
using System.ClientModel.Primitives;
using System.Text.Json;

#pragma warning disable OPENAI001

BearerTokenPolicy tokenPolicy = new(
    new DefaultAzureCredential(),
    "https://ai.azure.com/.default");

ChatClient client = new(
    model: "gpt-4.1",
    authenticationPolicy: tokenPolicy,
    options: new OpenAIClientOptions()
    {
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
    }
);

ChatCompletionOptions options = new()
{
    ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
        jsonSchemaFormatName: "math_reasoning",
        jsonSchema: BinaryData.FromBytes("""
            {
                "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
            }
            """u8.ToArray()),
        jsonSchemaIsStrict: true)
};

// Create a list of ChatMessage objects
ChatCompletion completion = client.CompleteChat(
    [
        new UserChatMessage("How can I solve 8x + 7 = -23?")
    ],
    options);

using JsonDocument structuredJson = JsonDocument.Parse(completion.Content[0].Text);

Console.WriteLine($"Final answer: {structuredJson.RootElement.GetProperty("final_answer")}");
Console.WriteLine("Reasoning steps:");

foreach (JsonElement stepElement in structuredJson.RootElement.GetProperty("steps").EnumerateArray())
{
    Console.WriteLine($"  - Explanation: {stepElement.GetProperty("explanation")}");
    Console.WriteLine($"    Output: {stepElement.GetProperty("output")}");
}

using OpenAI;
using OpenAI.Chat;
using System.ClientModel;
using System.Text.Json;

string keyFromEnvironment = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");

ChatClient client = new(
    model: "gpt-4o-mini",
    credential: new ApiKeyCredential(keyFromEnvironment),
    options: new OpenAIClientOptions() { 
        Endpoint = new Uri("https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1")
    }
);

ChatCompletionOptions options = new()
{
    ResponseFormat = ChatResponseFormat.CreateJsonSchemaFormat(
        jsonSchemaFormatName: "math_reasoning",
        jsonSchema: BinaryData.FromBytes("""
            {
                "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
            }
            """u8.ToArray()),
        jsonSchemaIsStrict: true)
};

// Create a list of ChatMessage objects
ChatCompletion completion = client.CompleteChat(
    [
        new UserChatMessage("How can I solve 8x + 7 = -23?")
    ],
    options);

using JsonDocument structuredJson = JsonDocument.Parse(completion.Content[0].Text);

Console.WriteLine($"Final answer: {structuredJson.RootElement.GetProperty("final_answer")}");
Console.WriteLine("Reasoning steps:");

foreach (JsonElement stepElement in structuredJson.RootElement.GetProperty("steps").EnumerateArray())
{
    Console.WriteLine($"  - Explanation: {stepElement.GetProperty("explanation")}");
    Console.WriteLine($"    Output: {stepElement.GetProperty("output")}");
}

Verwenden Sie strukturierte Ausgaben mit der Responses API

Die .NET Antwort-API unterstützt die JSON-Schemaanforderungskonfiguration. Es gibt das strukturierte Ergebnis als JSON-Text zurück, anstatt es automatisch in einen .NET Typ zu deserialisieren.

Erstellen Sie eine Mit dem Schema benannte calendar-event-schema.json Datei:

{
    "type": "object",
    "properties": {
        "name": { "type": "string" },
        "date": { "type": "string" },
        "participants": {
            "type": "array",
            "items": { "type": "string" }
        }
    },
    "required": ["name", "date", "participants"],
    "additionalProperties": false
}

Übergeben Sie das Schema an ResponseTextFormat.CreateJsonSchemaFormat, und lesen Sie den JSON-Code aus GetOutputText:

#pragma warning disable OPENAI001
using Azure.Identity;
using OpenAI.Responses;
using System.ClientModel.Primitives;

// Create a client that uses Microsoft Entra ID.
string endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1";
ResponsesClient openAIClient = new(
    authenticationPolicy: new BearerTokenPolicy(
        new DefaultAzureCredential(), "https://ai.azure.com/.default"),
    options: new ResponsesClientOptions { Endpoint = new Uri(endpoint) });

// Configure and send the structured-output request.
BinaryData calendarEventSchema = BinaryData.FromString(
    File.ReadAllText("calendar-event-schema.json"));
CreateResponseOptions options = new()
{
    Model = "gpt-5-mini",
    InputItems = { ResponseItem.CreateUserMessageItem(
        "Extract event information from: Alice and Bob are going to a science fair on Friday.") },
    TextOptions = new ResponseTextOptions
    {
        TextFormat = ResponseTextFormat.CreateJsonSchemaFormat(
            "CalendarEventResponse", calendarEventSchema,
            jsonSchemaIsStrict: true)
    }
};

ResponseResult response = await openAIClient.CreateResponseAsync(options);
Console.WriteLine(response.GetOutputText());

Ausgabe:

{"name":"Science Fair","date":"Friday","participants":["Alice","Bob"]}

Voraussetzungen

• Ein Azure-Abonnement.
• Eine Azure OpenAI-Ressource mit einer gpt-5-mini-Modellbereitstellung. Informationen zum Erstellen einer Ressource und Bereitstellen eines Modells finden Sie unter Erstellen einer Ressource und Bereitstellen eines Modells mit Azure OpenAI.
• Ihr Azure OpenAI v1-Endpunkt, wie https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/.
• Für die Microsoft Entra ID-Authentifizierung, eine Identität, der für die Azure OpenAI-Ressource die Rolle Cognitive Services OpenAI User zugewiesen ist. Installieren Sie die Azure CLI und führen Sie anschließend az login aus.
• Bei der API-Schlüsselauthentifizierung wird ein in der Umgebungsvariablen AZURE_OPENAI_API_KEY gespeicherter Azure OpenAI-Ressourcenschlüssel gespeichert.

Einrichten

Die Beispiele erfordern Node.js 22 oder höher. Erstellen Sie ein Projekt, konfigurieren Sie ECMAScript-Module, und installieren Sie die Pakete OpenAI, Zod und Azure Identity:

npm init --yes
npm pkg set type=module
npm install openai zod @azure/identity
npm install --save-dev typescript tsx @types/node

Speichern Sie für TypeScript jedes Beispiel als structured-outputs.ts, und führen Sie es dann aus:

npx tsx structured-outputs.ts

Speichern Sie für JavaScript jedes Beispiel als structured-outputs.mjs, und führen Sie es dann aus:

node structured-outputs.mjs

Verwenden Sie strukturierte Ausgaben mit Chat Completions

Definieren Sie die Ausgabestruktur mit Zod. Die zodResponseFormat Hilfsfunktion wandelt das Zod-Objekt in ein strenges JSON-Schema um und validiert die Modellantwort. Alle Eigenschaften im Zod-Objekt sind erforderlich, es sei denn, Sie definieren eine nullfähige Union.

import {
  DefaultAzureCredential,
  getBearerTokenProvider,
} from "@azure/identity";
import OpenAI from "openai";
import { zodResponseFormat } from "openai/helpers/zod";
import { z } from "zod/v4";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://ai.azure.com/.default",
);
const openai = new OpenAI({ baseURL: endpoint, apiKey: tokenProvider });
const CalendarEvent = z.object({
  name: z.string(),
  date: z.string(),
  participants: z.array(z.string()),
});

const completion = await openai.chat.completions.parse({
  model: "gpt-5-mini",
  messages: [
    { role: "system", content: "Extract the event information." },
    {
      role: "user",
      content: "Alice and Bob are going to a science fair on Friday.",
    },
  ],
  response_format: zodResponseFormat(CalendarEvent, "calendar_event"),
});
const message = completion.choices[0]?.message;
if (message?.refusal) throw new Error(`Request refused: ${message.refusal}`);
if (!message?.parsed) throw new Error("The response wasn't parsed.");
console.log(message.parsed);

import OpenAI from "openai";
import { zodResponseFormat } from "openai/helpers/zod";
import { z } from "zod/v4";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const apiKey = process.env["AZURE_OPENAI_API_KEY"];
if (!apiKey) throw new Error("AZURE_OPENAI_API_KEY is required.");
const openai = new OpenAI({ baseURL: endpoint, apiKey });
const CalendarEvent = z.object({
  name: z.string(),
  date: z.string(),
  participants: z.array(z.string()),
});

const completion = await openai.chat.completions.parse({
  model: "gpt-5-mini",
  messages: [
    { role: "system", content: "Extract the event information." },
    {
      role: "user",
      content: "Alice and Bob are going to a science fair on Friday.",
    },
  ],
  response_format: zodResponseFormat(CalendarEvent, "calendar_event"),
});
const message = completion.choices[0]?.message;
if (message?.refusal) throw new Error(`Request refused: ${message.refusal}`);
if (!message?.parsed) throw new Error("The response wasn't parsed.");
console.log(message.parsed);

Die Ausgabe sieht in etwa wie folgt aus:

{
  name: 'Science Fair',
  date: 'Friday',
  participants: [ 'Alice', 'Bob' ]
}

Verwenden Sie strukturierte Ausgaben mit der Responses API

Übergeben Sie für die Responses API das Ergebnis von zodTextFormat unter text.format. Der geparste Wert ist nach Abschluss der Antwort über output_parsed verfügbar.

import {
  DefaultAzureCredential,
  getBearerTokenProvider,
} from "@azure/identity";
import OpenAI from "openai";
import { zodTextFormat } from "openai/helpers/zod";
import { z } from "zod/v4";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://ai.azure.com/.default",
);
const openai = new OpenAI({ baseURL: endpoint, apiKey: tokenProvider });
const CalendarEvent = z.object({
  name: z.string(),
  date: z.string(),
  participants: z.array(z.string()),
});

const response = await openai.responses.parse({
  model: "gpt-5-mini",
  input:
    "Extract the event information: Alice and Bob are going to a science " +
    "fair on Friday.",
  text: { format: zodTextFormat(CalendarEvent, "calendar_event") },
});
if (response.status !== "completed") {
  const details = response.error ?? response.incomplete_details;
  throw new Error(JSON.stringify(details));
}
const refusal = response.output
  .flatMap((item) => item.type === "message" ? item.content : [])
  .find((content) => content.type === "refusal");
if (refusal) throw new Error(`Request refused: ${refusal.refusal}`);
if (!response.output_parsed) throw new Error("The response wasn't parsed.");
console.log(response.output_parsed);

Die Ausgabe sieht in etwa wie folgt aus:

{
  name: 'Science Fair',
  date: 'Friday',
  participants: [ 'Alice', 'Bob' ]
}

Verwenden Sie strukturierte Ausgaben für Funktionsaufrufe

Verwenden Sie zodFunction, um ein striktes Funktions-Tool zu erstellen und seine Argumente zu parsen. Azure OpenAI unterstützt keine parallelen Funktionsaufrufe mit strukturierten Ausgaben, setzen Sie also parallel_tool_calls auf false.

import {
  DefaultAzureCredential,
  getBearerTokenProvider,
} from "@azure/identity";
import OpenAI from "openai";
import { zodFunction } from "openai/helpers/zod";
import { z } from "zod/v4";

const endpoint = "https://YOUR-RESOURCE-NAME.openai.azure.com/openai/v1/";
const tokenProvider = getBearerTokenProvider(
  new DefaultAzureCredential(),
  "https://ai.azure.com/.default",
);
const openai = new OpenAI({ baseURL: endpoint, apiKey: tokenProvider });
const DeliveryRequest = z.object({ order_id: z.string() });

const completion = await openai.chat.completions.parse({
  model: "gpt-5-mini",
  messages: [
    { role: "system", content: "Use the supplied tool to help the user." },
    { role: "user", content: "When will order 12345 be delivered?" },
  ],
  tools: [zodFunction({
    name: "get_delivery_date",
    description: "Get the delivery date for an order.",
    parameters: DeliveryRequest,
  })],
  parallel_tool_calls: false,
});
const toolCall = completion.choices[0]?.message.tool_calls?.[0];
if (toolCall?.type !== "function") {
  throw new Error("No function call returned.");
}
console.log(toolCall.function.parsed_arguments);

Die Ausgabe sieht in etwa wie folgt aus:

{ order_id: '12345' }

Verwenden Sie für die zugrunde liegenden Anforderungs-Shapes ohne Zod die JSON-Schemabeispiele in der REST-Sprachoption.

Erste Schritte

response_format ist auf json_schema mit strict: true festgelegt.

curl -X POST  https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/chat/completions \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
    -d '{
        "model": "YOUR_MODEL_DEPLOYMENT_NAME",
        "messages": [
                {"role": "system", "content": "Extract the event information."},
                {"role": "user", "content": "Alice and Bob are going to a science fair on Friday."}
            ],
            "response_format": {
                "type": "json_schema",
                "json_schema": {
                    "name": "CalendarEventResponse",
                    "strict": true,
                    "schema": {
                        "type": "object",
                        "properties": {
                            "name": {
                              "type": "string"
                            },
                            "date": {
                                "type": "string"
                            },
                            "participants": {
                                "type": "array",
                                "items": {
                                    "type": "string"
                                }
                            }
                        },
                        "required": [
                            "name",
                            "date",
                            "participants"
                        ],
                        "additionalProperties": false
                    }
                }
          }
  }'

Ausgabe:

{
  "id": "chatcmpl-A1HKsHAe2hH9MEooYslRn9UmEwsag",
  "object": "chat.completion",
  "created": 1724868330,
  "model": "gpt-4o-2024-08-06",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "{\n  \"name\": \"Science Fair\",\n  \"date\": \"Friday\",\n  \"participants\": [\"Alice\", \"Bob\"]\n}"
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 33,
    "completion_tokens": 27,
    "total_tokens": 60
  },
  "system_fingerprint": "fp_1c2eaec9fe"
}

Verwenden Sie strukturierte Ausgaben mit der Responses API

Definieren Sie für die Antwort-API das JSON-Schema unter text.format. Festlegen type, , name, schema, und strict als gleichgeordnete Eigenschaften von format. Bevor Sie die Anfrage ausführen, legen Sie für AZURE_OPENAI_AUTH_TOKEN ein Microsoft Entra ID-Zugriffstoken fest.

curl -X POST https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/responses \
  -H "Authorization: Bearer $AZURE_OPENAI_AUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5-mini",
    "input": "Extract the event information from: Alice and Bob are going to a science fair on Friday.",
    "text": {
      "format": {
        "type": "json_schema",
        "name": "CalendarEventResponse",
        "schema": {
          "type": "object",
          "properties": {
            "name": {"type": "string"},
            "date": {"type": "string"},
            "participants": {
              "type": "array",
              "items": {"type": "string"}
            }
          },
          "required": ["name", "date", "participants"],
          "additionalProperties": false
        },
        "strict": true
      }
    }
  }'

Der output_text Inhalt enthält:

{
  "name": "Science Fair",
  "date": "Friday",
  "participants": ["Alice", "Bob"]
}

Funktionsaufrufe mit strukturierten Ausgaben

curl -X POST  https://YOUR_RESOURCE_NAME.openai.azure.com/openai/v1/chat/completions \
  -H "api-key: $AZURE_OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "YOUR_MODEL_DEPLOYMENT_NAME",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant. The current date is August 6, 2024. You help users query for the data they are looking for by calling the query function."
    },
    {
      "role": "user",
      "content": "look up all my orders in may of last year that were fulfilled but not delivered on time"
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "query",
        "description": "Execute a query.",
        "strict": true,
        "parameters": {
          "type": "object",
          "properties": {
            "table_name": {
              "type": "string",
              "enum": ["orders"]
            },
            "columns": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "id",
                  "status",
                  "expected_delivery_date",
                  "delivered_at",
                  "shipped_at",
                  "ordered_at",
                  "canceled_at"
                ]
              }
            },
            "conditions": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "column": {
                    "type": "string"
                  },
                  "operator": {
                    "type": "string",
                    "enum": ["=", ">", "<", ">=", "<=", "!="]
                  },
                  "value": {
                    "anyOf": [
                      {
                        "type": "string"
                      },
                      {
                        "type": "number"
                      },
                      {
                        "type": "object",
                        "properties": {
                          "column_name": {
                            "type": "string"
                          }
                        },
                        "required": ["column_name"],
                        "additionalProperties": false
                      }
                    ]
                  }
                },
                "required": ["column", "operator", "value"],
                "additionalProperties": false
              }
            },
            "order_by": {
              "type": "string",
              "enum": ["asc", "desc"]
            }
          },
          "required": ["table_name", "columns", "conditions", "order_by"],
          "additionalProperties": false
        }
      }
    }
  ]
}'