Automatizza le attività di Google Workspace con l'API Gemini

1. Prima di iniziare

In questo codelab, imparerai ad automatizzare le attività di Google Workspace con le funzionalità di chiamata di funzione e multimodalità dell'API Gemini.

Prerequisiti

• Familiarità di base con Apps Script, JavaScript o un linguaggio di programmazione simile.

Cosa imparerai

• Come sfruttare le chiamate di funzione e le funzionalità multimodalità dell'API Gemini.
• Come concatenare più chiamate API Gemini.
• Come automatizzare le attività di Google Workspace con l'API Gemini.

Cosa serve

• Un browser web.
• Un account Gmail. In alternativa, un account Google Workspace che ha implementato la configurazione specifica dell'API Gemini.
• Una connessione da una regione supportata per l'API Gemini.
• (Facoltativo) Un'interfaccia a riga di comando con il programma curl per testare le richieste API dirette.

Nota: in questo codelab utilizzi Apps Script. Non è necessario avere esperienza diretta con Apps Script perché la sintassi è molto simile a JavaScript e ad altri linguaggi simili.

Il codice completo di questo codelab è disponibile nel Libro di ricette dell'API Gemini su GitHub. Controlla se ti serve il codice completo.

2. Configura l'API Gemini

Informazioni su Gemini

I modelli Gemini sono la famiglia di modelli IA più ampia e avanzata di Google. Per sfruttare questi modelli nelle tue app, puoi utilizzare l'API Gemini. Puoi anche provare l'API Gemini in Google AI Studio, un'interfaccia web per l'API in cui puoi provare prompt, modificare le impostazioni del modello e ottimizzare i modelli personalizzati senza scrivere alcun codice.

Ottieni una chiave

• Per utilizzare l'API Gemini, crea una chiave API in Google AI Studio.

(Facoltativo) Testare la chiave

Se hai accesso a una riga di comando con curl, aggiungi la chiave nella prima riga del blocco seguente, quindi eseguila nel terminale per testare la chiave API.

export GOOGLE_API_KEY=Paste_your_API_key_here

curl "https://generativelanguage.googleapis.com/v1beta/models?key=${GOOGLE_API_KEY}"

Dovresti vedere un elenco di modelli in formato JSON, ad esempio templates/gemini-1.0-pro. Ciò significa che ha funzionato.

3. (Facoltativo) Inviare una richiesta all'API Gemini

In questo passaggio facoltativo, invierai una richiesta all'API Gemini per capire meglio come funziona la generazione di contenuti prima di aggiungerla a un'app Apps Script.

Informazioni sui modelli

L'API Gemini fornisce una serie di modelli con capacità e limitazioni diverse. Tutti i modelli sono elencati insieme alle loro capacità nella pagina dei modelli Gemini.

La tua prima richiesta

Per fare in modo che l'API Gemini completi un prompt di testo, devi creare una richiesta JSON e inviarla all'endpoint API REST.

Per farlo, segui questi passaggi:

1. In un nuovo file, inserisci la seguente richiesta JSON:

{
  contents: [
   {
     parts: [
       { text: 'The most important aspects of a persuasive presentation are:' }
     ]
   }
 ]
}

La richiesta JSON include il seguente prompt: The most important aspects of a persuasive presentation are:. Il modello completerà questa istruzione e ti fornirà direttamente il risultato.

La richiesta JSON ha tre campi di primo livello da compilare: contents, generationConfig e safetySettings. È obbligatorio solo contents. Gli altri forniscono meccanismi per controllare l'output.

2. Salva questo JSON in un file presentation.txt e poi lo passi direttamente a curl in questo modo:

curl -H 'Content-Type: application/json' -X POST -d @presentation.txt \
  'https://generativelanguage.googleapis.com/v1beta/models/gemini-1.0-pro-latest:generateContent?key='${GOOGLE_API_KEY}

In questo esempio, imposti i seguenti valori nell'URL:

• v1beta specifica la versione API.
• gemini-1.0-pro-latest specifica Gemini 1.0 Pro come modello e utilizza lo snapshot più recente.
• generateContent specifica il metodo API che chiami.

Dovresti vedere risultati simili ai seguenti:

{
  "candidates": [
    {
      "content": {
        "parts": [
          {
            "text": "* **Credibility:** The audience must trust that you are an expert on the subject matter and that you have their best interests at heart.\n* **Clearness:** Your message must be easy to understand and follow. Avoid using jargon or technical terms that your audience may not be familiar with.\n* **Concreteness:** Use specific examples and data to support your arguments. Avoid making vague or general claims.\n* **Emotional appeal:** In addition to appealing to the audience's logical side, you should also try to connect with them on an emotional level. Use storytelling, humor, and personal anecdotes to make your points more memorable and engaging.\n* **Strong closing:** End your presentation with a strong call to action. Tell the audience what you want them to do and why it is important for them to do it."
          }
        ],
        "role": "model"
      },
      "finishReason": "STOP",
      "index": 0,
      "safetyRatings": [...]
    }
  ],
  "promptFeedback": {
    "safetyRatings": [...]
  }
}

Per una maggiore leggibilità, ecco l'output del terminale formattato regolarmente:

• Credibilità: il pubblico deve confidare nel fatto che tu sia un esperto dell'argomento e che tu abbia a cuore il suo interesse.
• Chiarezza:il messaggio deve essere facile da capire e seguire. Evita di usare gergo o termini tecnici che il tuo pubblico potrebbe non conoscere.
• Concreta: utilizza esempi e dati specifici a supporto dei tuoi argomenti. Evita di fare affermazioni vaghe o generiche.
• Impatto emotivo: oltre ad attirare il lato logico del pubblico, dovresti anche provare a entrare in contatto con lui a livello emotivo. Usa storytelling, umorismo e aneddoti personali per rendere i tuoi punti più memorabili e coinvolgenti.
• Chiusura efficace:termina la presentazione con un invito all'azione efficace. Spiega al pubblico cosa vuoi che facciano e perché è importante per loro.

Per scoprire di più sulle altre impostazioni, tra cui generationConfig e safetySettings, consulta le istruzioni e le guide alla sicurezza.

4. Chiamare l'API Gemini da Apps Script

1. Visita script.new per creare automaticamente un file code.gs Apps Script.
2. Tieni il cursore sul file code.gs e fai clic su > Rinomina.
3. Cambia il nome del file in utils.gs.
4. Rimuovi la funzione myFunction nel file in modo che il file sia vuoto.

Aggiungi la tua chiave API al progetto

1. Nel menu di navigazione, seleziona Impostazioni progetto.
2. In Proprietà script, fai clic su Aggiungi proprietà script.
3. In Proprietà, inserisci GOOGLE_API_KEY.
4. In Valore, inserisci la chiave API di Google AI Studio.

5. Fai clic su Salva proprietà script.
6. Torna all'editor.

Aggiungere il codice dell'API Gemini

Nel file utils.gs, segui questi passaggi:

Configura la chiave API e l'endpoint:

const properties = PropertiesService.getScriptProperties().getProperties();
const geminiApiKey = properties['GOOGLE_API_KEY'];
const geminiEndpoint = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.0-pro-latest:generateContent?key=${geminiApiKey}`;

1. Aggiungi la seguente funzione che chiama l'API Gemini con un prompt specifico:

function callGemini(prompt, temperature=0) {
  const payload = {
    "contents": [
      {
        "parts": [
          {
            "text": prompt
          },
        ]
      }
    ], 
    "generationConfig":  {
      "temperature": temperature,
    },
  };

  const options = { 
    'method' : 'post',
    'contentType': 'application/json',
    'payload': JSON.stringify(payload)
  };

  const response = UrlFetchApp.fetch(geminiEndpoint, options);
  const data = JSON.parse(response);
  const content = data["candidates"][0]["content"]["parts"][0]["text"];
  return content;
}

2. Aggiungi la funzione seguente che imposta il prompt:

function testGemini() {
  const prompt = "The best thing since sliced bread is";
  const output = callGemini(prompt);
  console.log(prompt, output);
}

Testa

1. Fai clic su Salva.
2. Scegli testGemini nell'elenco a discesa delle funzioni e fai clic su .
3. Accetta le autorizzazioni necessarie. Il codice dovrebbe essere eseguito e dovresti vedere l'output della console con i risultati nel log di esecuzione.

Ha funzionato!

5. Chiama l'API Gemini con le immagini

Una delle funzionalità più potenti della famiglia di modelli Gemini è il supporto dell'input multimodale, il che significa che puoi fornire molto di più del solo testo. In questa sezione, aggiungerai una funzione che chiama l'API Gemini con un'immagine.

• Nella parte superiore del file utils.gs, dopo la dichiarazione const geminiEndpoint esistente, aggiungi la seguente riga:

const geminiProVisionEndpoint = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.0-pro-vision-latest:generateContent?key=${geminiApiKey}`;

Aggiungi il codice Gemini Vision

1. Aggiungi una funzione al file utils.gs per chiamare questo endpoint appena aggiunto:

function callGeminiProVision(prompt, image, temperature=0) {
  const imageData = Utilities.base64Encode(image.getAs('image/png').getBytes());

  const payload = {
    "contents": [
      {
        "parts": [
          {
            "text": prompt
          },
          {
            "inlineData": {
              "mimeType": "image/png",
              "data": imageData
            }
          }          
        ]
      }
    ], 
    "generationConfig":  {
      "temperature": temperature,
    },
  };

  const options = { 
    'method' : 'post',
    'contentType': 'application/json',
    'payload': JSON.stringify(payload)
  };

  const response = UrlFetchApp.fetch(geminiProVisionEndpoint, options);
  const data = JSON.parse(response);
  const content = data["candidates"][0]["content"]["parts"][0]["text"];
  return content;
}

2. Aggiungi la seguente funzione di test:

function testGeminiVision() {
  const prompt = "Provide a fun fact about this object.";
  const image = UrlFetchApp.fetch('https://storage.googleapis.com/generativeai-downloads/images/instrument.jpg').getBlob();
  const output = callGeminiProVision(prompt, image);
  console.log(prompt, output);
}

Questa funzione carica un'immagine di test da internet e la passa alla funzione definita. In seguito, lo colleghi per utilizzare un grafico tratto da un foglio di lavoro, quindi si tratta solo di un test.

Testa

• Salva ed esegui la funzione testGeminiVision, quindi controlla l'output.

6. Chiamare l'API Gemini con gli strumenti

Oltre a testo e immagini, nei prompt puoi fornire l'accesso a strumenti.

Aggiungi il codice di gestione degli strumenti

• Aggiungi una funzione al file utils.gs che accetti la specifica di uno strumento:

function callGeminiWithTools(prompt, tools, temperature=0) {
  const payload = {
    "contents": [
      {
        "parts": [
          {
            "text": prompt
          },
        ]
      }
    ], 
    "tools" : tools,
    "generationConfig":  {
      "temperature": temperature,
    },    
  };

  const options = { 
    'method' : 'post',
    'contentType': 'application/json',
    'payload': JSON.stringify(payload)
  };

  const response = UrlFetchApp.fetch(geminiEndpoint, options);
  const data = JSON.parse(response);
  const content = data["candidates"][0]["content"]["parts"][0]["functionCall"];
  return content;
}

Per saperne di più su questo schema e sui campi disponibili, consulta la documentazione di riferimento dell'API FunctionDeclaration.

Testa

1. Definisci uno strumento che il modello può utilizzare per trovare la data e l'ora correnti:

function testGeminiTools() {
  const prompt = "Tell me how many days there are left in this month.";
  const tools = {
    "function_declarations": [
      {
        "name": "datetime",
        "description": "Returns the current date and time as a formatted string.",
        "parameters": {
          "type": "string"
        }
      }
    ]
  };
  const output = callGeminiWithTools(prompt, tools);
  console.log(prompt, output);
}

Il formato utilizzato qui è lo schema FunctionDeclaration. Non richiami effettivamente la funzione data-ora. Ricevi solo un'indicazione che il modello ha richiesto una chiamata di funzione. Potrai gestire le chiamate di funzione in un passaggio successivo.

2. Salva ed esegui la funzione testGeminiTools per visualizzare l'output.

7. Panoramica delle integrazioni dimostrative con Google Workspace

Ora che hai compreso come funzionano le chiamate di funzione, puoi estendere facilmente le funzionalità del modello Gemini ad altri servizi. Nelle sezioni successive, creerai integrazioni con prodotti Google Workspace come Google Drive, Presentazioni Google e Fogli Google. Ecco un diagramma semplificato:

A livello generale, quando arriva una query di un utente, puoi usare le chiamate di funzione dell'API Gemini per determinare quale strumento usare. Puoi creare tre strumenti in grado di fare quanto segue:

• Organizza una riunione. La funzione setupMeeting() nel diagramma richiama l'API Gemini 1.0 Pro per riassumere un blog su Google Drive e aggiungerlo a una riunione appena creata in Google Calendar.
• Prepara la bozza di un'email sulla base delle informazioni ricavate da un grafico. La funzione draftEmail() nel diagramma richiama Gemini 1.0 Pro Vision per analizzare un grafico in Fogli Google e scrivere un'email in Gmail in base all'analisi.
• Crea uno scheletro di presentazione. La funzione createDeck() nel diagramma richiama Gemini 1.0 Pro per fare brainstorming sugli elenchi puntati per una presentazione in Presentazioni Google.

Per ogni strumento, devi fare quanto segue:

1. Determina se la risposta alla chiamata della funzione dell'API Gemini chiede di richiamare quello specifico strumento in un blocco if...else.
2. Aggiungi la funzione effettiva per implementare la funzionalità dello strumento.
3. Dichiara lo strumento con l'API Gemini in modo che il modello Gemini sia a conoscenza dell'esistenza dello strumento e possa restituire la risposta corretta per la chiamata di funzione.

8. Organizzare una riunione con Apps Script

In primo luogo automatizzi la configurazione di una riunione in Google Calendar, ma aggiungi anche una descrizione, che è il riepilogo di un file su Google Drive.

Per farlo, segui questi passaggi:

1. Scarica questo file di testo, ovvero la copia testuale del blog sul lancio di Gemini 1.5 Pro.
2. Carica il file nella cartella principale di Google Drive.
3. Crea un file main.gs nell'editor e aggiungi il codice seguente:

function main() {
  const userQuery = "Set up a meeting at 10AM tomorrow with Helen to discuss the news in the Gemini-blog.txt file.";

  var tool_use = callGeminiWithTools(userQuery, WORKSPACE_TOOLS);
  Logger.log(tool_use);
  
  if(tool_use['name'] == "setupMeeting") {
    setupMeeting(tool_use['args']['time'], tool_use['args']['recipient'], tool_use['args']['filename']);
    Logger.log("Your meeting has been set up.");
 }
  else
    Logger.log("no proper tool found");
}

Qui puoi richiamare la funzionalità di chiamata di funzione dell'API Gemini. Poi devi definire la funzione dello strumento.

4. A sinistra dell'editor, accanto a Servizi, fai clic su + Aggiungi un servizio > API Google Calendar > Aggiungi. In questo modo si attiva il servizio avanzato di Google Calendar, che dovrai utilizzare in seguito per alcune API avanzate.

5. Nel file utils.gs, aggiungi il seguente codice:

function attachFileToMeeting(event, file, fileName) {
  // Get the iCal ID for the event.
  const iCalEventId = event.getId();

  // Log the ID and title for debugging.
  console.log(`iCal event ID: ${iCalEventId}`);
  console.log(`event Title: ${event.getTitle()}`);

  // Set up the options for listing the event with the advanced Google Calendar service.
  const options = {
      iCalUID: iCalEventId,
    };

  // Use the primary calendar as the calendar ID to list events.
  const calendarId = 'primary';

  // Use the advanced Google Calendar service to list the event.
  const calEvents = Calendar.Events.list(calendarId, options);

  // Get the Calendar ID used by the advanced Google Calendar service.
  const eventId = calEvents.items[0].id;

  // Get the file URL for the attachment.
  const fileUrl = file.getUrl();

    // Set up the patch options to add the file.
    var patch = {
      attachments: [{
        'fileUrl': fileUrl,
        'title': fileName
      }]
    };

    // Patch the event to add the file as an attachment.
    Calendar.Events.patch(patch, 'primary', eventId, {"supportsAttachments": true});  
}

function setupMeeting(time, recipient, filename) {
  const files = DriveApp.getFilesByName(filename);
  const file = files.next();
  const blogContent = file.getAs("text/*").getDataAsString();
  
  var geminiOutput = callGemini("Give me a really short title of this blog and a summary with less than three sentences. Please return the result as a JSON with two fields: title and summary. \n" +  blogContent);
  // The Gemini model likes to enclose the JSON with ```json and ```
  geminiOutput = JSON.parse(geminiOutput.replace(/```(?:json|)/g, ""));  
  const title = geminiOutput['title'];
  const fileSummary = geminiOutput['summary'];

  const event = CalendarApp.getDefaultCalendar().createEventFromDescription(`meet ${recipient} at ${time} to discuss "${title}"`); 
  event.setDescription(fileSummary);
  attachFileToMeeting(event, file, filename);
}

Questo codice esegue le seguenti operazioni:

• La funzione setupMeeting() passa attraverso Google Drive e trova il file Gemini-blog.txt. Questo nome file viene restituito automaticamente dalla chiamata di funzione dell'API Gemini nel passaggio 3.
• La funzione setupMeeting() chiama l'API Gemini per riassumere i contenuti del file, organizza una riunione con CalendarApp utilizzando una descrizione in formato libero e aggiunge il riepilogo alla riunione.
• La funzione setupMeeting() chiama la funzione attachFileToMeeting() per utilizzare il servizio avanzato di Google Calendar per allegare il file del blog alla riunione.

Nota: in questo codelab, istruirai esplicitamente il modello Gemini 1.0 Pro a restituire il risultato come JSON valido nel prompt. Per i modelli più recenti, come Gemini 1.5 Pro, puoi utilizzare direttamente il modello JSON.

6. Nella parte superiore del file utils.gs, aggiungi il seguente codice:

const WORKSPACE_TOOLS = {
 "function_declarations": [
   {
     "name": "setupMeeting",
     "description": "Sets up a meeting in Google Calendar.",
     "parameters": {
       "type": "object",
       "properties": {
         "time": {
           "type": "string",
           "description": "The time of the meeting."
         },
         "recipient": {
           "type": "string",
           "description": "The name of the recipient."
         },   
         "filename": {
           "type": "string",
           "description": "The name of the file."
         },                     
       },
       "required": [
         "time",
         "recipient",
         "filename"
       ]
     }
   },
   // You add tools here.        
 ]
};

7. Torna al file main.gs e fai clic su nell'editor.
8. Se Google Workspace ti chiede l'autorizzazione per eseguire lo script, fai clic su Ok.

Dopo pochi secondi, il log dell'esecuzione mostra un messaggio che ti informa che la riunione è configurata.

9. In Google Calendar, cerca la riunione con il riepilogo e l'allegato.

9. Prepara la bozza di un'email con Apps Script

Successivamente, automatizzi la bozza di un'email in Gmail. Ecco lo scenario: supponi di eseguire un'analisi dei dati in Fogli Google. Metti a posto tutti i numeri e crei un grafico. Vuoi utilizzare l'API Gemini Pro Vision per scrivere un'email in base al grafico.

Per farlo, segui questi passaggi:

1. Apri questo foglio e fai clic su File -> Crea una copia.
2. Nella casella di testo Nome della finestra di dialogo Copia documento, sostituisci il nome predefinito Copy of CollegeExpenses con CollegeExpenses.
3. Nel file main.gs, sostituisci la query utente precedente con una nuova, quindi aggiungi il seguente codice all'istruzione if...else:

function main() {
  // const userQuery = "Set up a meeting at 5PM with Helen to discuss the news in the Gemini-1.5-blog.txt file.";  
  const userQuery = "Draft an email for Mary with insights from the chart in the CollegeExpenses sheet.";

  if(...) {...}
  // Add this code
  else if(tool_use['name'] == "draftEmail") {
    draftEmail(tool_use['args']['sheet_name'], tool_use['args']['recipient']);
    Logger.log("Check your Gmail to review the draft");
  }
  else {...}

}

4. Nel file utils.gs, aggiungi il seguente codice:

function draftEmail(sheet_name, recipient) {
  
  const prompt = `Compose the email body for ${recipient} with your insights for this chart. Use information in this chart only and do not do historical comparisons. Be concise.`;

  var files = DriveApp.getFilesByName(sheet_name);
  var sheet = SpreadsheetApp.openById(files.next().getId()).getSheetByName("Sheet1");
  var expenseChart = sheet.getCharts()[0];

  var chartFile = DriveApp.createFile(expenseChart.getBlob().setName("ExpenseChart.png"));
  var emailBody = callGeminiProVision(prompt, expenseChart);
  GmailApp.createDraft(recipient+"@demo-email-provider.com", "College expenses", emailBody, {
      attachments: [chartFile.getAs(MimeType.PNG)],
      name: 'myname'
  });
}

Questa funzione recupera il grafico delle spese universitarie dal foglio e lo invia a Gemini Pro Vision per la bozza dell'email. Gemini Pro Vision estrae le informazioni dal grafico e scrive il corpo dell'email per tuo conto.

5. Nel file utils.gs, aggiungi il seguente codice all'oggetto WORKSPACE_TOOLS dopo il commento You add tools here:

  WORKSPACE_TOOLS = {
    "function_declarations": [
      // You add tools here.

      {
        "name": "draftEmail",
        "description": "Write an email by analyzing data or charts in a Google Sheets file.",
        "parameters": {
          "type": "object",
          "properties": {
            "sheet_name": {
              "type": "string",
              "description": "The name of the sheet to analyze."
            },
            "recipient": {
              "type": "string",
              "description": "The name of the recipient."
            },            
          },
          "required": [
            "sheet_name",
            "recipient"
          ]
        }
      },   


    ]
  };

6. Nell'editor, torna al file main.gs e fai clic su .
7. Dopo 10-20 secondi, apri Gmail. Dovresti visualizzare una bozza di email simile alla seguente:

Puoi rivedere la bozza dell'email prima di inviarla. L'email è stata scritta interamente da Gemini Pro Vision dopo che gli hai fornito un breve prompt e il grafico.

Nota: come best practice, conviene rivedere e personalizzare la bozza prima di inviarla.

10. Crea uno scheletro di presentazione con Apps Script

Successivamente, automatizzerai la creazione di uno scheletro di presentazione in Presentazioni Google con Apps Script.

Per farlo, segui questi passaggi:

1. Nel file main.gs, sostituisci la query utente precedente con una nuova e aggiungi il seguente codice all'istruzione if...else:

function main() {
  // const userQuery = "Draft an email for Mary with insights from the chart in the CollegeExpenses sheet.";
  const userQuery = "Help me put together a deck about water conservation.";

  if(...) {...}
  // Add this code
  else if(tool_use['name'] == 'createDeck') {
    deckURL = createDeck(tool_use['args']['topic']);
    Logger.log("Deck URL: " + deckURL);
  }
  else {...}

}

2. Nel file utils.gs, aggiungi il seguente codice:

function createDeck(topic) {
  const prompt = `I'm preparing a ${NUM_SLIDES}-slide deck to discuss ${topic}. Please help me brainstorm and generate main bullet points for each slide. Keep the title of each slide short. Please produce the result as a valid JSON so that I can pass it to other APIs.`;
  
  var geminiOutput = callGemini(prompt, 0.4);
  // The Gemini model likes to enclose the JSON with ```json and ```
  geminiOutput = geminiOutput.replace(/```(?:json|)/g, "");
  const bulletPoints = JSON.parse(geminiOutput);
    
  // Create a Google Slides presentation.
  const presentation = SlidesApp.create("My New Presentation");

  // Set up the opening slide.
  var slide = presentation.getSlides()[0]; 
  var shapes = slide.getShapes();
  shapes[0].getText().setText(topic);

  var body;
  for (var i = 0; i < NUM_SLIDES; i++) {
      slide = presentation.appendSlide(SlidesApp.PredefinedLayout.TITLE_AND_BODY);
      shapes = slide.getShapes();
      // Set title.
      shapes[0].getText().setText(bulletPoints['slides'][i]['title']);
  
      // Set body.
      body = "";
      for (var j = 0; j < bulletPoints['slides'][i]['bullets'].length; j++) {
        body += '* ' + bulletPoints['slides'][i]['bullets'][j] + '\n';
      }
      shapes[1].getText().setText(body);
  } 

  return presentation.getUrl();
}

Nota: in questo codelab, istruirai esplicitamente il modello Gemini 1.0 Pro a restituire il risultato come JSON valido nel prompt. Per i modelli più recenti, come Gemini 1.5 Pro, puoi utilizzare direttamente il modello JSON.

Questa funzione chiama l'API Gemini per fare brainstorming su un particolare argomento, restituisce gli elenchi puntati nel formato

di JSON e poi usare Apps Script per compilare uno scheletro di presentazione.

3. Nel file utils.gs, aggiungi il seguente codice all'oggetto WORKSPACE_TOOLS dopo il commento You add tools here:

  WORKSPACE_TOOLS = {
    "function_declarations": [
      // You add tools here.

      {
        "name": "createDeck",
        "description": "Build a simple presentation deck with Google Slides and return the URL.",
        "parameters": {
          "type": "object",
          "properties": {
            "topic": {
              "type": "string",
              "description": "The topic that the presentation is about."
            },
          },
          "required": [
            "topic"
          ]
        }
      },


    ]
  };

4. Nella parte superiore del file utils.gs, definisci la seguente costante:

const NUM_SLIDES = 3;

Questo è il numero di slide create dal modello Gemini oltre alla slide di apertura.

5. Nell'editor, torna al file main.gs e fai clic su . Dopo pochi secondi, vedrai l'URL di una presentazione nel log di esecuzione.
6. Utilizza il browser per aprire l'URL. Dovresti vedere uno scheletro pieno di elenchi puntati.

Nota: le slide sono molto basilari, ma puoi facilmente usare Apps Script per regolare il layout o aggiungere immagini per renderle più elaborate.

11. Idee da esplorare

Oltre a queste tre integrazioni, puoi esplorare le seguenti idee:

• Creare un chatbot su Google Chat Uno dei casi d'uso più comuni per i modelli linguistici di grandi dimensioni (LLM) è la creazione di un chatbot. Con l'API Gemini, è facile creare un chatbot per Google Chat. Per saperne di più, consulta l'API Google Chat e il codelab Creare app per Google Chat con Gemini.
• RAG (Retrieval-Augmented Generation) con i tuoi dati su Google Drive o Keep. In questo codelab, utilizzerai un solo file di testo per i riassunti. Tuttavia, puoi anche utilizzare i contenuti dei tuoi Google Drive personali e Keep (come note, PDF e immagini) con l'API Gemini, un database vettoriale e, facoltativamente, uno strumento di orchestrazione come LangChain, per eseguire la RAG e personalizzare la risposta del modello in base ai tuoi dati.
• Utilizzare la funzionalità di chiamata di funzione in più passaggi dell'API Gemini. Le chiamate di funzione dell'API Gemini non sono limitate a un turno e puoi chiamare di funzione in più passaggi per attività ancora più complesse.
• Vai oltre Google Workspace. Ora che sai come integrare l'API Gemini con Google Workspace, puoi andare oltre Google Workspace e sfruttare altre API in tutto il mondo.

12. Complimenti

Hai appreso le funzionalità multimodali e le chiamate di funzione dell'API Gemini. Li hai utilizzati per automatizzare alcune attività di Google Workspace con Apps Script.

Scopri di più

• Modelli di IA per l'API Gemini
• Chiamate di funzione di Gemini
• App Script di Google Workspace