Mit Custom GPTs kannst du individuelle KI-Assistenten erstellen, die auf spezifische Aufgaben zugeschnitten sind. Sie sind standardmäßig auf Textinteraktionen beschränkt – damit kratzt du aber nur an der Oberfläche von dem, was möglich ist.
Du kannst deine GPTs nämlich auch mit anderen Tools verknüpfen!
Genau hier kommt das Tool Make ins Spiel: Die Verknüpfung von Custom GPTs mit Make eröffnet völlig neue Möglichkeiten für Automatisierungen.
Du kannst deinen Custom GPT nämlich zum Trigger für Aktionen in anderen Tools machen – sei es um neue Termine im Kalender anzulegen, E-Mails zu versenden oder Daten zu speichern.
So wird dein KI-Assistent zu einem echten Multifunktionswerkzeug, das nicht nur Texte erstellt, sondern konkrete Aufgaben in deinem digitalen Arbeitsalltag erledigt. Die Möglichkeiten sind (fast() grenzenlos!
In diesem Artikel zeige ich dir Schritt für Schritt, wie du einen simplen Custom GPT so einrichtest, dass er Termine direkt in deinem Google Kalender anlegt. Das Prinzip lässt sich aber auf zahlreiche andere Anwendungsfälle übertragen.
Grundlagen zu Make.com verstehen
Make ist ein Automatisierungstool, mit dem du verschiedene Apps und Dienste miteinander verknüpfen kannst, die normalerweise keine direkte Integration bieten.
Ein Make-Szenario besteht grundsätzlich aus zwei Komponenten:
- Trigger: Ein Ereignis, das das Szenario startet (z.B. ein neuer Eintrag in einem Google Sheet oder – im Falle der Custom GPTs – das Empfangen von Daten über einen Webhook)
- Aktionen: Tätigkeiten, die daraufhin in verschiedenen Tools ausgeführt werden
Make funktioniert ähnlich wie Zapier, bietet aber teilweise etwas mehr Flexibilität und Anpassungsmöglichkeiten. Außerdem kannst du Europa als Serverstandort auswählen.
Der Ablauf ist immer gleich: Etwas löst den Workflow aus, und dann werden automatisch weitere Aktionen in anderen Tools ausgeführt.
Das kann sehr simpel oder sehr komplex werden!
Was sind Webhooks?
Die sog. Webhooks spielen bei der Verknüpfung von Custom GPTs mit Make eine zentrale Rolle.
Ein Webhook funktioniert wie eine "Empfangsstation" für Daten – er stellt eine URL bereit, an die Daten gesendet werden können, die dann weiterverarbeitet werden.
In unserem Fall werden die Daten, die wir im Custom GPT eingeben (wie Termindetails für den Kalendereintrag), an Make geschickt und dort verarbeitet.
Wie du das einrichtest, zeig ich dir natürlich gleich!
Vorbereitung für die Verknüpfung
Bevor wir mit Make loslegen, müssen wir einen Custom GPT erstellen und mit den richtigen Instruktionen versehen. In unserem Beispiel erstellen wir einen "Appointment Setter", der Termine im Google Kalender anlegen kann.
Hier sind einmal beispielhaft die wichtigsten Punkte für die Instruktionen des GPTs:
Aufgabe und Ablauf:
Du legst Aufgaben im Google Kalender an über die Aktion "create_event".
Vom User brauchst du:
- Name des Events (Pflichtfeld)
- Startzeit (Pflichtfeld)
- Dauer (optional)
- Endzeit (optional)
Wenn nicht alle relevanten Informationen bereits in der ersten Nachricht geliefert werden, fragst du noch mal nach. Betone dabei vor allem, dass die Dauer des Events relevant ist, damit du den Kalendereintrag sinnvoll anlegen kannst. Wenn keine Dauer genannt wird, gehe von einer Stunde aus.
Regel für das Zeitformat:
Übertrage Start- und Endzeit im ISO-Format (YYYY-MM-DDTHH:MM:SS).
Als Gesprächsaufhänger kannst du bspw. "Neues Event anlegen" festlegen, das ist aber optional.
1. Szenario in Make erstellen
Jetzt geht's an die Einrichtung in Make. Dafür benötigst du einen Make-Account – für den Anfang reicht die kostenlose Variante völlig aus.
Webhook als Trigger einrichten
- Klicke auf "Create a new scenario".
- Wähle "Webhook" als erstes Modul aus.
- Wähle die Option "Custom webhook".
- Klicke auf "Create a webhook" und gib einen Namen ein (z.B. "Appointment Setter").
- Make erstellt eine Webhook-URL – die brauchen wir später noch.
- Speichere das Modul, wenn das ganze bei dir jetzt auch so aussieht:
Make wartet nun darauf, dass Daten an diese URL gesendet werden. Bevor wir soweit sind, fehlen aber noch ein paar weitere Schritte.
Google Kalender als Aktion hinzufügen
- Klicke auf das Plus-Zeichen nach dem Webhook-Modul.
- Wähle "Google Calendar" als App aus.
- Wähle "Create an event" als Aktion.
- Verknüpfe deinen Google-Account, falls du das noch nicht getan hast.
- Bei den Feldern "Event Name" und "Start Date" handelt es sich um Pflichtfelder, "End Date" und "Duration" sind optional. Hier fügst du jetzt noch NICHTS ein! Diese Felder werden wir später mit den Daten aus dem Webhook verbinden.
Lass das Modul erst einmal offen, wir kommen später darauf zurück.
2. OpenAPI Schema erstellen
Um die Verknüpfung zwischen deinem Custom GPT und Make herzustellen, benötigst du ein OpenAPI Schema. Dieses Schema definiert, welche Daten von deinem GPT an Make gesendet werden und wie sie strukturiert sind.
Du kannst ein Schema manuell erstellen, aber es ist viel einfacher, einen Assistenten zu verwenden. Deswegen hab ich den kostenlosen OpenAPI Schema Creator erstellt, der führt dich Schritt für Schritt durch den Prozess!
Hier sind die Hauptelemente, die dein Schema enthalten sollte (zeigt der Schema Creator dir aber auch alles):
- Name, Beschreibung und Version: z.B. "Event Creator", "Erstellt Events im Google Kalender" und "1.0.0"
- Server-URL: Hier fügst du die Webhook-URL ein, die du von Make erhalten hast
- Operations-ID: Diese muss mit der ID übereinstimmen, die du in den Instruktionen deines GPTs verwendet hast (z.B. "create_event")
- Parameter: Definiere die Parameter, die du an Make senden möchtest:
event_name(String, Pflichtfeld)start_time(String, Pflichtfeld)duration(Integer, optional)end_time(String, optional)
- Antwortnachrichten: Definiere, welche Nachrichten bei Erfolg oder Misserfolg angezeigt werden sollen
Das vollständige Schema sieht dann etwa so aus:
{
"openapi": "3.0.0",
"info": {
"title": "Event Creator",
"description": "Erstellt Events im Google Kalender",
"version": "1.0.0"
},
"servers": [
{
"url": "https://hook.eu1.make.com/your-webhook-url"
}
],
"paths": {
"/": {
"post": {
"operationId": "create_event",
"summary": "Erstellt ein neues Event im Google Kalender",
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"type": "object",
"required": [
"event_name",
"start_time"
],
"properties": {
"event_name": {
"type": "string",
"description": "Name des Events"
},
"start_time": {
"type": "string",
"description": "Startzeit des Events"
},
"duration": {
"type": "integer",
"description": "Dauer des Events in Minuten"
},
"end_time": {
"type": "string",
"description": "Endzeit des Events"
}
}
}
}
}
},
"responses": {
"200": {
"description": "Event erfolgreich erstellt"
},
"400": {
"description": "Fehler bei der Event-Erstellung"
}
}
}
}
}
}
3. Verknüpfung abschließen
Nachdem du das OpenAPI Schema erstellt hast, kannst du es in deinen Custom GPT einfügen:
- Öffne deinen Custom GPT im Bearbeitungsmodus.
- Scrolle zum Bereich "Actions" (Aktionen).
- Klicke auf "Add action" (Aktion hinzufügen).
- Füge dein Schema ein.
- Die Aktion (z.B. "create_event") sollte jetzt erscheinen.
Jetzt musst du Make noch einmal öffnen, um die Datenstruktur zu bestimmen:
- Öffne dein Make-Szenario.
- Klicke auf das Webhook-Modul.
- Wähle "Redetermine data structure".
- Führe einen Testlauf mit deinem GPT durch (z.B. "Neuer Termin Weekly Checkin, Startzeit 28. Februar um 16 Uhr, Dauer 60 Minuten").
- Erlaube die Aktion in deinem GPT.
Wenn alles funktioniert hat, sollte Make die Daten empfangen haben. Jetzt kannst du die Felder im Google Kalender-Modul mit den entsprechenden Daten aus dem Webhook verbinden:
- Klicke auf das Google Kalender-Modul.
- Wähle den gewünschten Kalender aus.
- Verbinde das Feld "Event Name" mit dem "event_name" aus dem Webhook.
- Verbinde "Start Date" mit "start_time".
- Verbinde optional "End Date" mit "end_time" und "Duration" mit "duration".
Speichere dein Szenario und aktiviere es, indem du den Regler unten auf grün schaltest.
4. Testlauf: Kalendereintrag erstellen
Jetzt ist alles eingerichtet und du kannst einen Testlauf durchführen:
- Öffne deinen Custom GPT.
- Gib einen Befehl ein, z.B.: "Erstelle einen Termin für das Weekly Meeting am 28. Februar um 16 Uhr".
- Dein GPT wird die Aktion ausführen und die Daten an Make senden.
- Make erstellt den Termin in deinem Google Kalender.
- Der GPT bestätigt die erfolgreiche Erstellung.
Schau in deinen Google Kalender – der Termin sollte jetzt dort eingetragen sein!
Fazit
Die Verknüpfung von Custom GPTs mit Make eröffnet dir jede Menge neuer Möglichkeiten. Im Beispiel haben wir einen Terminplaner erstellt, aber du kannst das Prinzip auf beliebige andere Anwendungsfälle übertragen:
- E-Mails versenden
- Daten in Tabellen speichern
- Aufgaben in Projektmanagement-Tools anlegen
- Social Media Posts erstellen
- ...und vieles mehr!
Das Grundprinzip ist immer gleich: Der Custom GPT dient als Schnittstelle, über die Daten erfasst und dann an Make weitergegeben werden. Make wiederum verarbeitet diese Daten und führt die gewünschten Aktionen in anderen Tools aus.
Wenn du einmal verstanden hast, wie die Verknüpfung funktioniert, kannst du deine eigenen, maßgeschneiderten Automatisierungen erstellen und so die Möglichkeiten von Custom GPTs erheblich erweitern.
