OpenAI Assistants Function Calling the Easy Way Using Make (Formerly Integromat)

Sometimes the things that don't make sense end up being the hardest to understand, even though they're actually quite simple. That's what happened to me with function calling from an assistant in OpenAI.

Yes, I know there are tons of videos on YouTube, tutorials, and all that, but most require you to create a backend in any language — luckily one of my favorites (Python). But after a while of thinking, I realized that the backend already exists, and it's Make, where I can receive requests from the assistant via a webhook, process them, and return the processed information… Wait, but how — how do I tell my assistant to use my webhook, and above all, how do I tell it to analyze what it returns?

Well, here in this realistic and simple tutorial, I'm going to teach you with practical examples. The only theory you'll read is what the knowledge from this example leaves in your curiosity to keep learning — because now that I know how simple it is, I can understand more things. But seriously, you learn by seeing, although I must tell you that I learned by doing, failing, and reading. But now I see the simplicity of the matrix.

Alright, enough of the blah blah — hands on the mouse :) and keyboard.

Here's a list of things we need. If you're reading this, we both know you have:

1. An OpenAI account (API access).
2. A Make account and OpenAI connection — if not, create one here.
3. An API to call, or any other service connected to Make. For this example let's take Google Calendar, to validate whether we have time for the proposed meeting time.

Step 1 — Create Assistant

Well, first let's create an assistant from openai.com. This will be extremely simple, because what we will actually be looking at is how function calls work, and to make it super simple, let's just create the assistant with this simple prompt:

Step 2 — Test Assistant

Now it would be good to do some tests in the playground to see how the assistant reacts with this simplest prompt. For example, let's tell our assistant that we want to book an appointment for next Friday.

Ummmm, although the response seems well-crafted, it is not what we need. What we want is for the assistant to communicate with our Google Calendar and tell us if there is availability. It responded to me with something as generic as this:

Step 3 — Create the function definition

This is where we're going; we'll create a function to make the call.

Here are a couple of good tips to know: OpenAI defines a function to be called when, within the context of the conversation, it's determined that the required information exists to make the call. This definition is a schema in JSON format (in official openai.com words: A function is defined by its schema, which informs the model what it does and what input arguments it expects.).

In the box that describes what the function does, write or paste what we need. In this case, this is what we'll write: Check if there's an available slot in the calendar for the given date and time. If available, request the name and email to confirm the booking. Event duration is 1 hour, and date-time format should be in the format DD-MM-YYYY HH:MM AM/PM.

Click Save, and here we have our function definition.

Step 4 — Test the function calling in the playground

Now let's test our Assistant again to check the function calling in the playground.

Bang! After starting the conversation, the Assistant asked for the necessary information. Once the information is collected, the function is invoked.

"Okay, everything is working, but how do I get the information from Google Calendar, and how can I integrate this into Make? It's easy — let's now connect OpenAI and Google Calendar in Make.com."

Step 5 — Connect Assistant to Make and prepare backend

This process involves several sub-steps to receive information through a webhook in Make. The OpenAI assistant processes the received information, and upon function invocation, it sends a request to the "backend" to connect with Google Calendar. The response is then returned to the assistant, which processes it to deliver a reply consistent with the function's result.

We will set up two Make scenarios:

Scenario 1 — Backend

• A backend webhook where the assistant sends the request to Google Calendar.
• For demonstration purposes, a single Message Assistant module to receive the request destined for the assistant.

Let's make it simple: take the address of the Custom webhook in your backend scenario and copy it for the next step. Your scenario should look like this:

• Webhook
• Get Free/Busy Information module
• Router — Branch 1 for available slot and creation of the event
• Create an Event
• Response Webhook (response with new event information)
• Router — Branch 2
• Webhook response for the no-available-slot response.

Scenario 2 — OpenAI.com Assistant

This scenario is quite simple but includes a couple of crucial points to consider. First, when you select our Assistant, you'll notice there's a function available — yes, it's the function we defined earlier. Even more importantly, there's a URL parameter. This parameter specifies where the assistant will send the JSON-formatted data collected during the conversation.

To illustrate, I sent a message to the Assistant that includes today's date (keep in mind that OpenAI has a data cutoff and may not have the most current date information).

Now, here's where the real magic happens.

Ensure both of your scenario windows are open and visible. Start by running the first scenario; once it's actively running, execute the second scenario. This second scenario is where we send the message to the assistant.

You will observe that our first backend scenario becomes active and processes the request. Subsequently, you'll see how the second scenario receives the information with the created event.

By this stage, we have successfully invoked a function from an OpenAI assistant using Make. This integration highlights how data flows from the assistant to a backend process via webhooks, allowing for real-time interaction and information processing between OpenAI and Google Calendar. If you want a hand designing this kind of workflow, our AI automation services cover exactly this.

Want to go further with Make? Learn how to return data to callers with webhook responses in Make, add voice input by wiring up ChatGPT Whisper in Make, or generate documents on the fly with dynamic PDFs in Make.

I hope you found this article helpful and insightful.

Frequently asked questions

How do you use OpenAI function calling without code?

You point your OpenAI Assistant's function to a Make (Integromat) webhook instead of a custom backend. When the model decides to call the function, it sends the collected arguments as JSON to that webhook, Make runs the actual work — calling APIs, checking a calendar, creating records — and returns the result to the assistant. No traditional server code required.

Can Make.com handle OpenAI Assistants function calls?

Yes. Make.com acts as the backend for OpenAI Assistants function calling: a Custom webhook receives the function arguments, Make modules process them and connect to services like Google Calendar, and a Webhook Response returns data the assistant can interpret and reply with. Two scenarios — one backend and one that talks to the assistant — are enough to make it work end to end.

What is function calling in the OpenAI Assistants API?

Function calling lets an OpenAI Assistant trigger an external action defined by a JSON schema. The schema tells the model what the function does and which arguments it expects. During a conversation the model decides when it has the required information, then emits those arguments so your system — a backend or a Make webhook — can perform the action and feed the result back.