Function-calling with an OpenAPI specification

Much of the internet is powered by RESTful APIs. Giving GPT the ability to call them opens up a world of possibilities. This notebook demonstrates how GPTs can be used to intelligently call APIs. It leverages OpenAPI specifications and chained function calls.

The OpenAPI Specification (OAS) is a universally accepted standard for describing the details of RESTful APIs in a format that machines can read and interpret. It enables both humans and computers to understand the capabilities of a service, and it can be leveraged to show GPT how to call APIs.

This notebook is divided into two main sections:

How to convert a sample OpenAPI specification into a list of function definitions for the chat completions API.
How to use the chat completions API to intelligently invoke these functions based on user instructions.

We recommend familiariazing yourself with function-calling before proceding.

How to convert an OpenAPI specification into function definitions

The example OpenAPI spec we use here was created using gpt-4. We will transform this sample spec into a set of function definitions that can be supplied to the chat completion API. The model, based on the provided user instructions, generates a JSON object containing the necessary arguments to call these functions.

Before we proceed, let's inspect this generated spec. OpenAPI specs include details about the API's endpoints, the operations they support, the parameters they accept, the requests they can handle, and the responses they return. The spec is defined in JSON format.

The endpoints in the spec include operations for:

Listing all events
Creating a new event
Retrieving an event by ID
Deleting an event by ID
Updating an event name by ID

Each operation in the spec has an operationId, which we will use as the function name when we parse the spec into function specifications. The spec also includes schemas that define the data types and structures of the parameters for each operation.

You can see the schema here:

{'openapi': '3.0.0', 'info': {'version': '1.0.0', 'title': 'Event Management API', 'description': 'An API for managing event data'}, 'paths': {'/events': {'get': {'summary': 'List all events', 'operationId': 'listEvents', 'responses': {'200': {'description': 'A list of events', 'content': {'application/json': {'schema': {'type': 'array', 'items': {'type': 'object', 'properties': {'id': {'type': 'string'}, 'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}}}}}, 'post': {'summary': 'Create a new event', 'operationId': 'createEvent', 'requestBody': {'required': True, 'content': {'application/json': {'schema': {'type': 'object', 'properties': {'id': {'type': 'string'}, 'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}}, 'responses': {'201': {'description': 'The event was created', 'content': {'application/json': {'schema': {'type': 'object', 'properties': {'id': {'type': 'string'}, 'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}}}}}, '/events/{id}': {'get': {'summary': 'Retrieve an event by ID', 'operationId': 'getEventById', 'parameters': [{'name': 'id', 'in': 'path', 'required': True, 'schema': {'type': 'string'}}], 'responses': {'200': {'description': 'The event', 'content': {'application/json': {'schema': {'type': 'object', 'properties': {'id': {'type': 'string'}, 'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}}}}, 'delete': {'summary': 'Delete an event by ID', 'operationId': 'deleteEvent', 'parameters': [{'name': 'id', 'in': 'path', 'required': True, 'schema': {'type': 'string'}}], 'responses': {'204': {'description': 'The event was deleted'}}}, 'patch': {'summary': "Update an event's details by ID", 'operationId': 'updateEventDetails', 'parameters': [{'name': 'id', 'in': 'path', 'required': True, 'schema': {'type': 'string'}}], 'requestBody': {'required': True, 'content': {'application/json': {'schema': {'type': 'object', 'properties': {'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}}, 'responses': {'200': {'description': "The event's details were updated", 'content': {'application/json': {'schema': {'type': 'object', 'properties': {'id': {'type': 'string'}, 'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}}}}}}, 'components': {'schemas': {'Event': {'type': 'object', 'properties': {'id': {'type': 'string'}, 'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}}

Now that we have a good understanding of the OpenAPI spec, we can proceed to parse it into function specifications.

We can write a simple openapi_to_functions function to generate a list of definitions, where each function is represented as a dictionary containing the following keys:

name: This corresponds to the operation identifier of the API endpoint as defined in the OpenAPI specification.
description: This is a brief description or summary of the function, providing an overview of what the function does.
parameters: This is a schema that defines the expected input parameters for the function. It provides information about the type of each parameter, whether it is required or optional, and other related details.

For each of the endpoints defined in the schema, we need to do the following:

Resolve JSON references: In an OpenAPI specification, it's common to use JSON references (also known as $ref) to avoid duplication. These references point to definitions that are used in multiple places. For example, if multiple API endpoints return the same object structure, that structure can be defined once and then referenced wherever it's needed. We need to resolve and replace these references with the content they point to.
Extract a name for the functions: We will simply use the operationId as the function name. Alternatively, we could use the endpoint path and operation as the function name.
Extract a description and parameters: We will iterate through the description, summary, requestBody and parameters fields to populate the function's description and parameters.

Here's the implementation:

def openapi_to_functions(openapi_spec): functions = [] for path, methods in openapi_spec["paths"].items(): for method, spec_with_ref in methods.items(): # 1. Resolve JSON references. spec = jsonref.replace_refs(spec_with_ref) # 2. Extract a name for the functions. function_name = spec.get("operationId") # 3. Extract a description and parameters. desc = spec.get("description") or spec.get("summary", "") schema = {"type": "object", "properties": {}} req_body = ( spec.get("requestBody", {}) .get("content", {}) .get("application/json", {}) .get("schema") ) if req_body: schema["properties"]["requestBody"] = req_body params = spec.get("parameters", []) if params: param_properties = { param["name"]: param["schema"] for param in params if "schema" in param } schema["properties"]["parameters"] = { "type": "object", "properties": param_properties, } functions.append( {"name": function_name, "description": desc, "parameters": schema} ) return functions functions = openapi_to_functions(openapi_spec) for function in functions: pp(function) print()

{'name': 'listEvents', 'description': 'List all events', 'parameters': {'type': 'object', 'properties': {}}} {'name': 'createEvent', 'description': 'Create a new event', 'parameters': {'type': 'object', 'properties': {'requestBody': {'type': 'object', 'properties': {'id': {'type': 'string'}, 'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}}}} {'name': 'getEventById', 'description': 'Retrieve an event by ID', 'parameters': {'type': 'object', 'properties': {'parameters': {'type': 'object', 'properties': {'id': {'type': 'string'}}}}}} {'name': 'deleteEvent', 'description': 'Delete an event by ID', 'parameters': {'type': 'object', 'properties': {'parameters': {'type': 'object', 'properties': {'id': {'type': 'string'}}}}}} {'name': 'updateEventDetails', 'description': "Update an event's details by ID", 'parameters': {'type': 'object', 'properties': {'requestBody': {'type': 'object', 'properties': {'name': {'type': 'string'}, 'date': {'type': 'string', 'format': 'date-time'}, 'location': {'type': 'string'}}, 'required': ['name', 'date', 'location']}, 'parameters': {'type': 'object', 'properties': {'id': {'type': 'string'}}}}}}

How to call these functions with GPT

Now that we have these function definitions, we can leverage GPT to call them intelligently based on user inputs.

It's important to note that the chat completions API does not execute the function; instead, it generates the JSON that you can use to call the function in your own code.

For more information on function-calling, refer to our dedicated function-calling guide.

SYSTEM_MESSAGE = """ You are a helpful assistant. Respond to the following prompt by using function_call and then summarize actions. Ask for clarification if a user request is ambiguous. """ # Maximum number of function calls allowed to prevent infinite or lengthy loops MAX_CALLS = 5 def get_openai_response(functions, messages): return openai.ChatCompletion.create( model="gpt-3.5-turbo-16k-0613", functions=functions, function_call="auto", # "auto" means the model can pick between generating a message or calling a function. temperature=0, messages=messages, ) def process_user_instruction(functions, instruction): num_calls = 0 messages = [ {"content": SYSTEM_MESSAGE, "role": "system"}, {"content": instruction, "role": "user"}, ] while num_calls < MAX_CALLS: response = get_openai_response(functions, messages) message = response["choices"][0]["message"] if message.get("function_call"): print(f"\n>> Function call #: {num_calls + 1}\n") pp(message["function_call"]) messages.append(message) # For the sake of this example, we'll simply add a message to simulate success. # Normally, you'd want to call the function here, and append the results to messages. messages.append( { "role": "function", "content": "success", "name": message["function_call"]["name"], } ) num_calls += 1 else: print("\n>> Message:\n") print(message["content"]) break if num_calls >= MAX_CALLS: print(f"Reached max chained function calls: {MAX_CALLS}") USER_INSTRUCTION = """ Instruction: Get all the events. Then create a new event named AGI Party. Then delete event with id 2456. """ process_user_instruction(functions, USER_INSTRUCTION)

>> Function call #: 1 {'name': 'listEvents', 'arguments': '{}'} >> Function call #: 2 {'name': 'createEvent', 'arguments': '{\n' ' "requestBody": {\n' ' "id": "1234",\n' ' "name": "AGI Party",\n' ' "date": "2022-12-31",\n' ' "location": "New York"\n' ' }\n' '}'} >> Function call #: 3 {'name': 'deleteEvent', 'arguments': '{\n "parameters": {\n "id": "2456"\n }\n}'} >> Message: Actions summary: 1. Retrieved all the events successfully. 2. Created a new event named "AGI Party" with ID 1234, scheduled for December 31, 2022, in New York. 3. Deleted the event with ID 2456.

Conclusion

We have demonstrated how to convert OpenAPI specs into function specifications that can be given to GPT for it to intelligently call them, and shown how these can be chained together to perform complex operations.

Possible extensions of this system could include handling more complex user instructions that require conditional logic or looping, integrating with real APIs to perform actual operations, and improving error handling and validation to ensure the instructions are feasible and the function calls are successful.