Make AI: A Guide With Practical Examples

What Is Make?

Make is a no-code automation tool where you can easily automate complex processes involving one or more tools. Automations are built by combining blocks called modules. Typically, a module corresponds to an action on a tool, for example, fetching the latest email or adding a row to a spreadsheet. 

The example above uses three modules to process email into a spreadsheet:

• The first module loads the latest email.
• The second module uses ChatGPT to process and extract information from the email.
• The third module writes a new row in a Google Sheet with the information extracted by ChatGPT.

How to Use Make?

To use Make and follow along in this tutorial, you’ll need to make an account on the official login page.

While Make is a proprietary tool, everything we teach in this tutorial can be done using a free Make account, which allows for 1,000 monthly operations. For more details, check their pricing page.

One operation represents the execution of a module. So, for example, the workflow above would consume three operations for each execution. This shows 1,000 operations are sufficient to build and test workflows.

Creating Our First AI Automation With Make

Since Make is similar to n8n, I tried recreating a workflow I had built in this n8n tutorial to get a better feel for how it compares. You don’t need to have read that tutorial to follow along, but it’s a good reference if you’re interested in comparing n8n with Make.

I rent part of my house, so I share the bills with my tenant. Each time I receive an invoice, I manually add a new line in a shared spreadsheet with the service provider (electricity, water, internet, etc.), invoice ID, amount to pay, and period.

You'll likely not have this use case, but you can easily follow along with something similar. If you're out of ideas and want to execute the workflow yourself, you can make it summarize the emails and write the summary on the spreadsheet.

Automating these kinds of repetitive tasks is where these AI automation tools shine the most.

Step 1: Reading the emails

Assuming you created a free Make account, navigate to the "Scenarios" tab on the left and click "Create a new scenario."

You should now see an empty canvas with a big + button. The first step in the workflow is to check our email. To do so, click the button and search for "gmail" to locate the Gmail / Watch Emails module.

The first step will be to create a connection to the email account. They provide detailed steps for doing so by clicking the "online help" link below the connection.

The steps are different depending on whether it is a company address or a personal address.

To configure the Gmail module, I use the following settings:

The filter part is a standard Gmail filter that ensures only invoices are considered. 

Step 2: Gathering information with AI

In the case of my invoices, the information I care about is sent directly in the email, so I don't need to process the attachment.

To extract the data, I use an OpenAI / Create a Completion module. This module allows for sending one or more messages to an OpenAI model and receiving a response. In this case, it's configured with a system prompt that tells the LLM what information we want, and then a user message with the email content.

Here is the configuration (the other fields were left with default values):

To use this module, I had to create a connection to OpenAI. As with the email connection, they provide a guide, but in this case, it's much easier. We need to create an OpenAI API key and paste it.

Step 3: Adding the information into a Google sheet

The last step is to send the invoice information into a Google sheet. This is done using a Google Sheet / Add a Row module.

Here's the configuration of this module:

In Make, all outputs from previous modules are available in subsequent modules. Thus, we can combine the data of the email and OpenAI to populate the spreadsheet.

Note that we need to run the OpenAI module once for the fields from its output to be identified and assigned.

Step 4: Automating the agent

To automate this scenario, we can configure it to run periodically as shown below:

Depending on the trigger module (the first module), we get different automation options.

Make vs. n8n

I've built the previous workflow with both Make and n8n. In both cases, I tried using the tool without following a tutorial to evaluate how easy and intuitive they are to use. I found Make to be less intuitive to work with.

• In Make, the output of the OpenAI module is strange to configure. We need to specify the JSON format in the prompt. Because of this, the output fields aren't defined before running the scenario at least once, making it annoying to configure.

• In general, I found it harder to know what the outputs of Make modules are beforehand.

• The connection process to external tools is the same for both tools. 

• I didn't need to use the attachment files, but using them didn't seem straightforward. I needed to either upload them to an OpenAI assistant that needed to be created beforehand or make a custom API request, which I found not easy to configure. In the completion module, they have a field to send in images, so they could easily have added a field for files since the OpenAI API supports it.

Second Use Case: Automating Customer Service With Make

In this section, we see how to use Make to create a customer service AI agent.

In this example, we imagine having a rental property and a Tally form where users can ask questions about our rental. The goal is to create an autonomous agent that replies to users' questions.

Here's an overview of the flow we'll create:

Step 1: Creating the form

For the form, we used Tally, which allows us to create online forms for free. Our form is pretty simple:

Step 2: Watching for new responses

The trigger module for this scenario is a Tally / Watch New Responses module. To configure it, we need to provide the ID of the Tally form.

Step 3: Retrieving the rental information

To answer customer questions, we created a Google Doc with all the relevant information about our rental property. We use a Google Docs / Get Content of a Document module to retrieve the content of the document.

Again, configuring this module is very easy. We create a Google Doc with the information and configure the module with the document ID.

Note that all the information we used in the document about the property is fictitious and was AI-generated for this example.

Step 4: Answering the question

To answer the question, we again use an OpenAI / Create a Completion module. We use a system message to explain the behavior we expect and provide the rental information. Then, the user's question is sent as a user message.

Step 5: Responding to the user

The final step is to send the answer to the user's email address, which is provided in the form. For this, we use an Email / Send an Email module.

This module is configured to send the email to the email address provided in the Tally form, using OpenAI's response as the email body.

Example

To automate this agent, we toggle "Immediately as data arrives" at the bottom. This will cause it to be executed as soon as a user asks a new question. 

Here's an example of a form and the response. 

Scenarios VS AI-Agents

In this tutorial, we built AI agents using the scenario feature. However, Make provides a beta AI agents feature that is more suitable for building agents. Unfortunately, this feature doesn't have a free tier.

We can do almost the same things using scenarios. The main difference is that when using AI, agents are more organized for complex scenarios. For example, we can create several scenarios that correspond to actions our agent will be able to perform. This separation makes it more organized.

Additionally, using AI agents provides a chat interface, allowing users to create agents with which they can interact directly.

Conclusion

Make offers a user-friendly platform for automating workflows without requiring any coding skills. 

By comparing it with n8n and building practical scenarios, we've seen its capabilities in streamlining tasks like invoice processing and automating customer service. Despite some intricacies in setting up certain modules, Make's extensive integrations and straightforward operation make it a valuable tool for businesses looking to enhance efficiency. 

While the AI agents feature could add more depth, its current capabilities with scenarios already offer significant advantages in creating automation solutions.