What are the types that can be passed as parameters? I can only seem to set the type as a string.
can you set more complex types? i.e Array, two dimensional Array, objects, etc
I’m sure I’m doing something wrong. If I set the type to array I get 400 Bad request
properties: {
key: {
type: "string",
description: "example description"
},
}
The other day I do remember seeing the JSON schema for OpenAI functions. I think I even bookmarked the web page because it was three degrees of separation from the blog page.
Sadly I cannot find the page nor the link.
However ChatGPT does seem to possess some knowledge of the JSON schema so prompted ChatGPT.
Prompt
ChatGPT May 24 Version
What is the JSON schema for OpenAI function properties for a two dimensional array.
Completion
As of my knowledge cutoff in September 2021, OpenAI does not provide a specific JSON schema for function properties that includes a two-dimensional array. However, you can define the structure of a two-dimensional array within the function properties using a nested array structure. Here’s an example of how you might structure the properties for an OpenAI function with a two-dimensional array using JSON:
json
{
"name": "MyFunction",
"description": "This is a sample function",
"parameters": [
{
"name": "array",
"type": "array",
"description": "Two-dimensional array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
],
"output": {
"type": "array",
"items": {
"type": "array",
"items": {
"type": "number"
}
}
}
}
In this example, the function has a parameter named “array” which is an array of arrays. The inner arrays represent rows in the two-dimensional array, and each element within the inner arrays represents a value in the two-dimensional array (in this case, numbers). The output of the function is also a two-dimensional array with the same structure.
Please note that the actual schema for OpenAI function properties may differ depending on the specific implementation and requirements of the OpenAI API. It’s always a good idea to refer to the official OpenAI documentation or resources for the most up-to-date and accurate information on function properties.
I have not tried this.
EDIT
IIRC this is what I found the other day, may or may not be correct.
This OpenAI API reference page
https://platform.openai.com/docs/api-reference/chat/create
Section: Create chat completion
notes
parameters object Optional
The parameters the functions accepts, described as a JSON Schema object. See the guide for examples, and the JSON Schema reference for documentation about the format.
Here is the noted JSON Schema
HTH
nice ok I will try this and see what happens 
I found using pydantic made things easier for me and worked well with str, int, lists and dictionaries.
Here is an example where I extract data from a set of user interviews.
...
from pydantic import BaseModel, Field
from typing import Optional, List
# define function structure in pydantic
class Topic(BaseModel):
name: str = Field(..., description="Classification category")
count: int = Field(..., description="Count for the category")
class ExtractInsightsParams(BaseModel):
interviewee_names: List[str] = Field(..., description="The names of the interviewees, e.g. Christoph, person y")
interviewee_count: int = Field(..., description="Number of people interviewed")
interview_topics: List[Topic] = Field(..., description="List of top 10 classification categories with their counts")
Then I use it in my function:
def get_completion_from_messages(messages,
model="gpt-3.5-turbo-16k-0613",
temperature=0):
response = openai.ChatCompletion.create(
model=model,
messages=messages,
temperature=temperature,
max_tokens=1000,
functions=[
{
"name": "extract_insights",
"description": "Extract insights from interviews",
"parameters": ExtractInsightsParams.schema()
}
],
function_call="auto",
)
print(response)
function_call = response.choices[0].message["function_call"]
arguments = json.loads(function_call["arguments"])
return arguments
Really clever way. Sometimes we cannot see the forest because of all the trees.
Is this with Pydantic 2.0? It didn’t work with 1.10.x
The schema() produces “$ref” references which refer to a definitions field in the schema and I think the API doesn’t understand that.
However, in general, one must write their own function, with JSON data types.
string
number
boolean
null/empty
object
array
Lets look at a demonstration of them all,
functions = [
{
"name": "data_demonstration",
"description": "This is the main function description",
"parameters": {
"type": "object",
"properties": {
"string_1": {"type": "string", "description": ""},
"number_2": {"type": "number", "description": ""},
"boolean_3": {"type": "boolean", "description": ""},
"empty_4": {"type": "null","description": "This is a description of the empty_4 null property"},
"string_5_enum": {"type": "string", "enum": ["Happy", "Sad"]},
},
"required": ["string_1","number_2","boolean_3", "empty_4", "string_5_enum"]
}
}
]
namespace functions {
// This is the main function description
type data_demonstration = (_: {
string_1: string,
number_2: number,
boolean_3: boolean,
// This is a description of the empty_4 null property
empty_4: any,
string_5_enum: "Happy" | "Sad",
}) => any;
} // namespace functions
{
..
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": null,
"function_call": {
"name": "data_demonstration",
"arguments": "{
"string_1": "Hello",
"number_2": 42,
"boolean_3": true,
"empty_4": null,
"string_5_enum": "Happy"
}"
}
},
"finish_reason": "function_call"
}
],...
(\n is rendered above for clarity)
functions = [
{
"name": "data_demonstration",
"description": "This is the main function description",
"parameters": {
"type": "object",
"properties": {
"object_1": {
"type": "object",
"description": "The object data type as a property",
"properties": {
"string_2a": {
"type": "string",
"enum": ["Happy", "Sad"]
},
"string_2b": {
"type": "string",
"description": "Description in a second object is lost"
},
},
},
"string_1": {"type": "string",
"description": "Not required gets a question mark"},
},
"required": ["object_1","placeholder_2"]
}
}
]
namespace functions {
// This is the main function description
type data_demonstration = (_: {
// The object data type as a property
object_1: {
string_2a: "Happy" | "Sad",
string_2b: string,
},
// Not required gets a question mark
string_1?: string,
}) => any;
} // namespace functions
Above we see a big failure that people don’t realize, nesting objects gets you no descriptions for the inner properties. They don’t have the “not required” question mark.
{...
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": null,
"function_call": {
"name": "data_demonstration",
"arguments": "{
"object_1": {
"string_2a": "Happy",
"string_2b": "Hello World"
},
"string_1": "Example data"
}"
}
},
"finish_reason": "function_call"
}
],
...
I hope you take the time to follow each of these properties through their specification to the ultimate API output.
There is one more JSON data type, array, which is equivalent to a Python list. Left as an exercise for you.
(Not explored, the method of setting the API function_call parameter from auto to “required” or “none”.)
Thanks for adding to the thread. I was not aware of this. Very helpful.