Google Sheet Integration

Integrate Google Sheets with MaiAgent using Google Apps Script to call Agents from a spreadsheet and batch-process multiple inputs with a custom function. Includes the complete script and a demo video

This page explains how to use Google Apps Script to integrate MaiAgent’s powerful AI capabilities into Google Sheets. You can call your MaiAgent Chatbot directly from a spreadsheet and batch-process multiple inputs to significantly improve efficiency.

Getting Started

Step 1: Open the Google Apps Script Editor

1. Open the Google Sheets spreadsheet you want to integrate with MaiAgent, or create a new spreadsheet.

2. Click “Extensions” > “Apps Script” in the top menu.

Step 2: Paste and Configure the Script

1. In the Apps Script editor, you will see a file named Code.gs. Clear its default contents.

2. Copy the complete Apps Script code provided by MaiAgent in the Attachment section below and paste it into Code.gs.

3. Replace API_KEY and CHATBOT_ID at the beginning of the script.

4. After making the changes, click the save icon (💾) at the top of the editor to save your script.

Using the MaiAgent Function in Google Sheets

Once you have completed the setup above and granted authorization, you can use the maiagent function in Google Sheets just like a built-in function.

1. Call an Agent Once

Enter a formula in the following format in any cell:

=maiagent("The message you want to send to the Agent")

For example:

• =maiagent("Hello, please introduce yourself")

• =maiagent("The weather is lovely today")

After you press Enter, the script sends your message to the specified Agent and displays the Agent’s response in the cell.

2. Read Message Content from Other Cells

You can have the maiagent function read the contents of other cells as input messages.

If cell A1 contains the message you want to send, enter the following in another cell, such as B1:

=maiagent(A1)

Cell B1 will then display MaiAgent’s response to the contents of A1.

Integration Demo Video

Conclusion

Integrating MaiAgent into Google Sheets through Google Apps Script opens up new possibilities for automation and productivity. Technical users can customize spreadsheets to meet their specific needs and turn them into powerful AI interaction tools for content generation, data analysis, and automated responses.

Attachment

Apps Script Code

// --- Define your API key and Chatbot ID here ---
const API_KEY = '<Replace with your actual API key>';
const CHATBOT_ID = '<Replace with your actual Chatbot ID>';
// --- --- --- --- --- --- --- --- --- --- --- ---

/**
 * Send a message to the MaiAgent API and return the response content directly.
 * Use the constants defined at the beginning of the script for the API key and Chatbot ID.
 * is_streaming is always false; conversation and attachments are not sent.
 *
 * @param {string} messageContent The message content to send.
 * @return {string} The value of the "content" field in the API response, or an error message.
 */
function maiagent(messageContent) {
  // Check whether API_KEY and CHATBOT_ID have been configured
  if (API_KEY === 'YOUR_API_KEY' || CHATBOT_ID === 'YOUR_CHATBOT_ID') {
    const warningMessage = 'Warning: The API key or Chatbot ID has not been configured in the script. Edit the script and replace YOUR_API_KEY and YOUR_CHATBOT_ID.';
    Logger.log(warningMessage);
    // Optionally throw an error here or return a warning to prevent invalid API calls
    // throw new Error(warningMessage);
    return warningMessage;
  }

  const url = `https://api.maiagent.ai/api/v1/chatbots/${CHATBOT_ID}/completions/`;

  const payload = {
    message: {
      content: messageContent
    },
    is_streaming: false
  };

  const options = {
    method: 'post',
    contentType: 'application/json',
    headers: {
      'Authorization': `Api-Key ${API_KEY}`
    },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true // Set to true to handle error messages the API may return
  };

  try {
    const response = UrlFetchApp.fetch(url, options);
    const responseCode = response.getResponseCode();
    const responseBody = response.getContentText();

    if (responseCode === 200) {
      Logger.log('API call succeeded:');
      Logger.log(responseBody); // Log the complete raw response for debugging
      try {
        const jsonResponse = JSON.parse(responseBody);
        if (jsonResponse && typeof jsonResponse.content !== 'undefined') {
          return jsonResponse.content; // Return the value of the content field directly
        } else {
          Logger.log('The API response succeeded, but the "content" field is missing or the format is invalid.');
          Logger.log(responseBody);
          return 'Error: The API response succeeded, but the "content" field is missing.';
        }
      } catch (parseError) {
        Logger.log(`Error parsing the API response JSON: ${parseError.toString()}`);
        Logger.log(`Raw response content: ${responseBody}`);
        return `Error: Failed to parse the API response - ${parseError.toString()}`;
      }
    } else {
      Logger.log(`API call failed, response code: ${responseCode}`);
      Logger.log(`Error response content: ${responseBody}`);
      return `Error: ${responseCode} - ${responseBody}`;
    }
  } catch (e) {
    Logger.log(`Exception during the API call: ${e.toString()}`);
    Logger.log(e.stack); // Log the stack trace for more detailed debugging
    return `Exception: ${e.toString()}`;
  }
}