API に Structured Outputs を導入

1
POST /v1/chat/completions
2
{
3
  "model": "gpt-4o-2024-08-06",
4
  "messages": [
5
    {
6
      "role": "system",
7
      "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."
8
    },
9
    {
10
      "role": "user",
11
      "content": "look up all my orders in may of last year that were fulfilled but not delivered on time"
12
    }
13
  ],
14
  "tools": [
15
    {
16
      "type": "function",
17
      "function": {
18
        "name": "query",
19
        "description": "Execute a query.",
20
        "strict": true,
21
        "parameters": {
22
          "type": "object",
23
          "properties": {
24
            "table_name": {
25
              "type": "string",
26
              "enum": ["orders"]
27
            },
28
            "columns": {
29
              "type": "array",
30
              "items": {
31
                "type": "string",
32
                "enum": [
33
                  "id",
34
                  "status",
35
                  "expected_delivery_date",
36
                  "delivered_at",
37
                  "shipped_at",
38
                  "ordered_at",
39
                  "canceled_at"
40
                ]
41
              }
42
            },
43
            "conditions": {
44
              "type": "array",
45
              "items": {
46
                "type": "object",
47
                "properties": {
48
                  "column": {
49
                    "type": "string"
50
                  },
51
                  "operator": {
52
                    "type": "string",
53
                    "enum": ["=", ">", "<", ">=", "<=", "!="]
54
                  },
55
                  "value": {
56
                    "anyOf": [
57
                      {
58
                        "type": "string"
59
                      },
60
                      {
61
                        "type": "number"
62
                      },
63
                      {
64
                        "type": "object",
65
                        "properties": {
66
                          "column_name": {
67
                            "type": "string"
68
                          }
69
                        },
70
                        "required": ["column_name"],
71
                        "additionalProperties": false
72
                      }
73
                    ]
74
                  }
75
                },
76
                "required": ["column", "operator", "value"],
77
                "additionalProperties": false
78
              }
79
            },
80
            "order_by": {
81
              "type": "string",
82
              "enum": ["asc", "desc"]
83
            }
84
          },
85
          "required": ["table_name", "columns", "conditions", "order_by"],
86
          "additionalProperties": false
87
        }
88
      }
89
    }
90
  ]
91
}

1
POST /v1/chat/completions
2
{
3
  "model": "gpt-4o-2024-08-06",
4
  "messages": [
5
    {
6
      "role": "system",
7
      "content": "You are a helpful math tutor."
8
    },
9
    {
10
      "role": "user",
11
      "content": "solve 8x + 31 = 2"
12
    }
13
  ],
14
  "response_format": {
15
    "type": "json_schema",
16
    "json_schema": {
17
      "name": "math_response",
18
      "strict": true,
19
      "schema": {
20
        "type": "object",
21
        "properties": {
22
          "steps": {
23
            "type": "array",
24
            "items": {
25
              "type": "object",
26
              "properties": {
27
                "explanation": {
28
                  "type": "string"
29
                },
30
                "output": {
31
                  "type": "string"
32
                }
33
              },
34
              "required": ["explanation", "output"],
35
              "additionalProperties": false
36
            }
37
          },
38
          "final_answer": {
39
            "type": "string"
40
          }
41
        },
42
        "required": ["steps", "final_answer"],
43
        "additionalProperties": false
44
      }
45
    }
46
  }
47
}

1
from enum import Enum
2
from typing import Union
3

4
from pydantic import BaseModel
5

6
import openai
7
from openai import OpenAI
8

9

10
class Table(str, Enum):
11
    orders = "orders"
12
    customers = "customers"
13
    products = "products"
14

15

16
class Column(str, Enum):
17
    id = "id"
18
    status = "status"
19
    expected_delivery_date = "expected_delivery_date"
20
    delivered_at = "delivered_at"
21
    shipped_at = "shipped_at"
22
    ordered_at = "ordered_at"
23
    canceled_at = "canceled_at"
24

25

26
class Operator(str, Enum):
27
    eq = "="
28
    gt = ">"
29
    lt = "<"
30
    le = "<="
31
    ge = ">="
32
    ne = "!="
33

34

35
class OrderBy(str, Enum):
36
    asc = "asc"
37
    desc = "desc"
38

39

40
class DynamicValue(BaseModel):
41
    column_name: str
42

43

44
class Condition(BaseModel):
45
    column: str
46
    operator: Operator
47
    value: Union[str, int, DynamicValue]
48

49

50
class Query(BaseModel):
51
    table_name: Table
52
    columns: list[Column]
53
    conditions: list[Condition]
54
    order_by: OrderBy
55

56

57
client = OpenAI()
58

59
completion = client.beta.chat.completions.parse(
60
    model="gpt-4o-2024-08-06",
61
    messages=[
62
        {
63
            "role": "system",
64
            "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.",
65
        },
66
        {
67
            "role": "user",
68
            "content": "look up all my orders in may of last year that were fulfilled but not delivered on time",
69
        },
70
    ],
71
    tools=[
72
        openai.pydantic_function_tool(Query),
73
    ],
74
)
75

76
print(completion.choices[0].message.tool_calls[0].function.parsed_arguments)

1
from pydantic import BaseModel
2

3
from openai import OpenAI
4

5

6
class Step(BaseModel):
7
    explanation: str
8
    output: str
9

10

11
class MathResponse(BaseModel):
12
    steps: list[Step]
13
    final_answer: str
14

15

16
client = OpenAI()
17

18
completion = client.beta.chat.completions.parse(
19
    model="gpt-4o-2024-08-06",
20
    messages=[
21
        {"role": "system", "content": "You are a helpful math tutor."},
22
        {"role": "user", "content": "solve 8x + 31 = 2"},
23
    ],
24
    response_format=MathResponse,
25
)
26

27
message = completion.choices[0].message
28
if message.parsed:
29
    print(message.parsed.steps)
30
    print(message.parsed.final_answer)
31
else:
32
    print(message.refusal)

1
{
2
  "model": "gpt-4o-2024-08-06",
3
  "messages": [
4
    {
5
      "role": "system",
6
      "content": "You are a helpful assistant"
7
    },
8
    {
9
      "role": "user",
10
      "content": "9.11 and 9.9 -- which is bigger?"
11
    }
12
  ],
13
  "response_format": {
14
    "type": "json_schema",
15
    "json_schema": {
16
      "name": "reasoning_schema",
17
      "strict": true,
18
      "schema": {
19
        "type": "object",
20
        "properties": {
21
          "reasoning_steps": {
22
            "type": "array",
23
            "items": {
24
              "type": "string"
25
            },
26
            "description": "The reasoning steps leading to the final conclusion."
27
          },
28
          "answer": {
29
            "type": "string",
30
            "description": "The final answer, taking into account the reasoning steps."
31
          }
32
        },
33
        "required": ["reasoning_steps", "answer"],
34
        "additionalProperties": false
35
      }
36
    }
37
  }
38
}

1
POST /v1/chat/completions
2
{
3
  "model": "gpt-4o-2024-08-06",
4
  "messages": [
5
    {
6
      "role": "system",
7
      "content": "Extract action items, due dates, and owners from meeting notes."
8
    },
9
    {
10
      "role": "user",
11
      "content": "...meeting notes go here..."
12
    }
13
  ],
14
  "response_format": {
15
    "type": "json_schema",
16
    "json_schema": {
17
      "name": "action_items",
18
      "strict": true,
19
      "schema": {
20
        "type": "object",
21
        "properties": {
22
          "action_items": {
23
            "type": "array",
24
            "items": {
25
              "type": "object",
26
              "properties": {
27
                "description": {
28
                  "type": "string",
29
                  "description": "Description of the action item."
30
                },
31
                "due_date": {
32
                  "type": ["string", "null"],
33
                  "description": "Due date for the action item, can be null if not specified."
34
                },
35
                "owner": {
36
                  "type": ["string", "null"],
37
                  "description": "Owner responsible for the action item, can be null if not specified."
38
                }
39
              },
40
              "required": ["description", "due_date", "owner"],
41
              "additionalProperties": false
42
            },
43
            "description": "List of action items from the meeting."
44
          }
45
        },
46
        "required": ["action_items"],
47
        "additionalProperties": false
48
      }
49
    }
50
  }
51
}