tool2schema 0.4.0

A library to generate function schemas for use in the OpenAI API.

tool2schema

A library to convert Python functions to schemas supported by the OpenAI API.

Inspired by janekb04/py2gpt and fastai/lm-hackers.

Why tool2schema?

The OpenAI API supports function calling. However, to tell GPT what functions it can call, you must send the functions in a JSON format. With tool2schema, functions can be automatically converted to the correct JSON schema!

Usage

On all functions that you would like to get JSON schema for, simply add the GPTEnabled decorator.

# my_functions.py
from tool2schema import GPTEnabled

@GPTEnabled
def my_function2(a: int, b: str = "Hello"):
    """
    Example function description.

    :param a: First parameter;
    :param b: Second parameter;
    """
    # Function code here...

@GPTEnabled(tags=["tag1"])
def my_function2(a: int, b: str = "Hello"):
    """
    Example function description.

    :param a: First parameter;
    :param b: Second parameter;
    """
    # Function code here...

tool2schema provides some methods to easily retrieve your functions.

import my_functions  # Module containing your functions
from tool2schema import FindGPTEnabled

# Return functions with GPTEnabled decorator
gpt_enable = FindGPTEnabled(my_functions)

# Return all function schemas
schemas = FindGPTEnabledSchemas(my_functions)

# Return function with given name
f = FindGPTEnabledByName(my_functions, "my_function1")

# Returns all functions with given tag
fs = FindGPTEnabledByTag(my_functions, "tag1")

How it Works

tool2schema uses certain features of your function to correctly populate the schema.

• Parameter type hints
• Parameter default values
• Docstring with parameter descriptions

The docstring must be of a specific format. An example function is defined below that utilises all of the above features.

def my_function(a: int, b: str = "Hello"):
    """
    Example function description.

    :param a: First parameter;
    :param b: Second parameter;
    """

Note the ; at the end of each parameter description. This is used to indicate the end of the parameter description.

To get the schema for this function, simply use the GPTEnabled decorator. The decorator will return a class with some additional attributes but can still be called as a function.

The schema of the function be accessed using the schema attribute.

my_function.schema.to_json()

This returns the function schema in JSON format.

Supported Parameter Types

The following parameter types are supported:

• int
• float
• str
• bool
• list

Any other parameter types will be listed as object in the schema.

Enumerations

If you want to limit the possible values of a parameter, you can use the enum keyword argument.

@GPTEnabled
def my_function(a: int, b: str,):
    """
    Example function description.

    :param a: First parameter;
    :param b: Second parameter;
    """
    # Function code here...
my_function.schema.add_enum("b", ["yes", "no"])

The schema will then be updated to include the enum keyword.

Tags

The GPTEnabled decorator also supports the tags keyword argument. This allows you to add tags to your function schema.

@GPTEnabled(tags=["tag1", "tag2"])
def my_function(a: int, b: str = "Hello"):
    """
    Example function description.

    :param a: First parameter;
    :param b: Second parameter;
    """
    # Function code here...

The tags can then be accessed using the tags attribute.

my_function.tags  # ["tag1", "tag2"]

You can check if a function has a certain tag using the has_tag method.

my_function.has_tag("tag1")  # True