Eigenes GPT mit dynamischer Datenbankanbindung: Mit ChatGPT & NocoDB

Custom GPTs in der bezahlten Version von OpenAI's ChatGPT bieten eine erweiterte Flexibilität und Anpassungsfähigkeit, indem sie es Nutzern ermöglichen, GPT4 auf spezifische Anwendungsfälle zu programmieren. Diese Anpassbarkeit reicht vom Prompt Engineering im Backend, über das Hochladen spezifischer Datensätze (Knowledge), bis hin zur Integration des Code Interpreters, des Web Browsings und der DALL·E Image Generation.

Mit Hilfe dieser Funktionen lassen sich eine Menge individueller Lösungen bauen. Nun kann es jedoch auch sein, dass man über Datensätze verfügt die sich stets ändern, neu hinzukommen etc.. Für diesen Fall beschreibe ich in diesem Artikel eine Möglichkeit Datenbanken anzubinden und durch ein Custom GPT durchsuchen zu lassen.

Vorweg: Je nachdem wie groß die Datenbank und ihre Spalten ist erfordert es viel Aufwand diverse Filter anzulegen und ChatGPT die Funktionsweise beizubringen. Hier ist ein genaues Prompt Engineering und beschreiben der API Schnittstelle unabdingbar.

Ebenso sei erwähnt, dass ich für eventuelle Schäden welche aus dieser Anleitung heraus resultieren könnten nicht hafte. Ich empfehle euch jeden Schritt selbst zu überprüfen, eure Systeme abzusichern und eventuelle Datenschutzbedenken abzuklären. In dieser Anleitung geht es lediglich um die Möglichkeiten und der Erstellung eines ersten Pilotens für euer Projekt.

GPT Funktionalitäten / Integrationen

Standardmäßig können wir an ein Custom GPT folgende Integrationen anbinden: den "Code Interpreter", das "Web Browsing" und die "DALL·E Image Generation". Diese helfen uns in spezifischen Anwendungsfällen auch in Kombination mit einer eigenen Datenbank Schnittstelle. Im folgenden beschreibe ich euch die drei Funktionen.

Coding & Datenanalyse: Code Interpreter

Der Code Interpreter ermöglicht die Ausführung und Analyse von Programmcode. Diese Funktion unterstützt eine Vielzahl von Programmiersprachen und kann für unterschiedliche Zwecke eingesetzt werden, wie zum Beispiel die Fehlerdiagnose in bestehenden Codes, die Optimierung von Programmierabläufen oder das Erstellen neuer Skripte. Besonders nützlich ist der Code Interpreter für diejenigen, die schnelle Lösungen für Programmierprobleme suchen oder Unterstützung beim Lernen neuer Sprachen benötigen.

Informationen aus dem Internet fetchen: Web Browsing

Das Web Browsing-Feature erlaubt es Informationen über die Bing Schnittstelle aus dem Internet zu beziehen, relevante Daten zu extrahieren und diese in die Beantwortung der Nutzeranfragen mit einfließen zu lassen. Da wir uns in diesem Artikel auf eigene Datenbanken fokussieren, deaktivieren wir diese Funktion. In gewissen Fällen kann es jedoch sinn ergeben die Funktion zu aktivieren.

Aus Text Prompts Bilder generieren: DALL·E Image Generation

Mit der Funktion "DALL·E Image Generation" lassen sich auch in einem Custom GPT Bilder mit Hilfe von Text Prompts generieren. Das reicht von einfachen Illustrationen bis hin zu komplexen realistischen Grafiken. Auch Texte können in diesen Bildern vorkommen. Hier hat Midjourney z.B. lange zeit hinterher gehangen.

Installation der Open Source Datenbank NocoDB

NocoDB ist eine Software / Plattform, die es uns ermöglicht, leistungsstarke und flexible Datenbanklösungen zu erstellen, ohne dabei auf komplexe Programmierung angewiesen zu sein.

Die NocoDB können wir sowohl in einer Cloud Edition nutzen (FREE / PAID - gehostet von https://nocodb.com/) als auch selbst auf einem eigenen Server betreiben. Besonders interessant an der NocoDB ist die einfache Handhabung. Mit ein paar Klicks lassen sich auch externe Quellen wie Postgres & MySQL Datenbanken anhängen. Ebenso gibt es Import Integrationen für z.B. JSON, CSV, Excel und Airtable. Steuern lässt sich das ganze über eine intuitive UI im Browser. Des Weiteren kann man aus der NocoDB heraus Webhooks senden um z.B. N8N, Zapier oder andere Dienste anzubinden. Das alles neben vielen weiteren Möglichkeiten Informationen anzulegen und zu filtern. Ausgelegt ist die NocoDB für Millionen von Datensätzen. Im Vergleich zu Baserow ist NocoDB jedoch etwas langsamer.

Um NocoDB selbst zu betreiben können wir z.B. Docker nutzen. Damit geht die Installation innerhalb von einigen Minuten von der Hand. Ebenso gibt es eine Möglichkeit das System über Node.js zu installieren. Falls ihr über eine Cloudron Instanz verfügt lässt sich die NocoDB mit einem Klick installieren. Eine genaue Anleitung findet ihr unter folgendem Link: Installation - NocoDB.

Installation mit Docker

Installation mit Docker Compose

Die docker-compose.yml Files findest du in diesem directory. Hier sind ein paar Beispiele:

Auch hier gelten die Hinweise von oben bezüglich der Volumes.

Installation mit NPX

Für eine interaktive Konfiguration kannst du folgenden Code ausführen:

npx create-nocodb-app

Weitere Möglichkeiten zu Installationen findest du auf der offiziellen Webseite der NocoDB: Installation - NocoDB

Erstellung einer NocoDB Datenbank

Zunächst legen wir eine Tabelle an, importieren Daten oder verbinden eine bereits bestehende Datenbank.

Anschließend vergeben wir spezifische Spaltennamen. Diese sollten im besten Fall so benannt sein, dass sie eine LLM ohne weiteres versteht. Wir arbeiten später mit den genauen Spaltennamen und keinen Spaltenvariablen. In meinem Beispiel handelt es sich um eine Auflistung von Analog Filmen mit Angaben zu technischen Daten, Hersteller und Produktinformationen sowie Beispielbildern um diese hinterher in dem Custom GPT anzeigen lassen zu können.

Haben wir unsere Tabelle / Datenbank angelegt und mit Informationen gefüttert, können wir uns die NocoDB API genauer anschauen. Unter dem Reiter "Details" und dann unter "APIs" wird uns angezeigt wie ein GET Request an unsere Datenbank aussehen würde. Wichtig hierbei ist, dass ihr über einen XC-AUTH Code verfügt welcher eure und später die Anfrage des custom GPTs "verifiziert".

Um einen XC-AUTH Code zu bekommen müsst ihr bei "Team & Einstellungen" auf "API-Tokens" klicken um dort Anwendungsspezifische Keys zu generieren. Soweit ich weiß kann man hier keine individuellen Berechtigungen vergeben. So wie: Darf nur DB / Tabelle X lesen. Daher empfiehlt es sich in nachfolgenden Schritten im Custom GPT nur bestimmte Requests zu beschreiben (OpenAPI SCHEMA) & Schreibprozesse in der DB oder andere Datenbankmanipulationen durch Nutzerinputs mit Prompt Engineering zu verhindern. Das Projekt "Baserow" bietet hier eine bessere Vergabe der API Berechtigungen. Bei Interesse zeige ich euch bei einer Aktualisierung wie wir auch Baserow an ein custom GPT anbinden.

Um nun ein wenig mit der Datenbank herumzuexperimentieren können wir den API-SWAGGER öffnen. Der zeigt uns genau an welche API Calls wir mit welchen Parametern tätigen können. Außerdem können wir dort alle Anfragen mit entsprechenden Parametern ausprobieren. Sehr hilfreich um später zu bestimmen welche Calls mit welchen Parameter wir mit dem Custom GPT nutzen möchten.

Nun können wir diverse INPUTS ausprobieren und uns die entsprechenden Responses anschauen. Es empfiehlt sich besonders bei einer frischen Installation die API über diesen Weg zu testen. Ebenfalls können wir in der Tabelle selbst unter Details & APIs den angegebenen CURL Befehl in unserem Terminal testen und schauen ob Werte aus unserer Datenbank zurück kommen.

Erstellung eines Custom GPTs

Nun kommen wir zum interessanten Teil der Anleitung. Dem Anbinden der Datenbank an ein eigenes CUSTOM GPT. Vorweg: Für die Einrichtung eines custom GPTs benötigen wir die bezahlte Version von ChatGPT. Außerdem haben wir auch hier eine beschränke Anzahl an GPT4 Nachrichten. Es kann uns also ziemlich schnell passieren, dass wir beim Testen unserer Schnittstelle an unsere Limitierungen geraten. Um dem zu entgehen können wir auch in den API Playground gehen und dort für unsere Requests bezahlen. Der Einfachheit halber fokussieren wir uns hier jedoch auf die gängige in ChatGPT integrierte Möglichkeit.

Bitte beachte, dass die Entwicklung hier sehr schnell voran schreitet. Somit kann es auch dazu kommen, dass du mit der Zeit Änderungen an deinen Prompts und Settings vornehmen musst.

In dem GPT Builder (linke Seite) können wir mit normaler Sprache (auch auf Deutsch) beschreiben welches "Problem" unser GPT Lösen / wie unser GPT handeln soll. Auf der rechten Seite können wir unsere Änderungen an den GPT Einstellungen sofort mit klassischen User Inputs testen. Hier testen und debuggen wir auch später unsere Datenbank Anbindung.

In bzw. unter dem Reiter "Configure" können wir unsere Settings komplett selbst vornehmen. Da der GPT Builder noch in der BETA ist kann es euch passieren das bei "unkonkreten" Eingaben euch der GPT Builder Fragen direkt beantwortet / im Internet recherchiert etc. ohne Einstellungen an dem GPT vorzunehmen. Ich bevorzuge daher die Einstellungen komplett manuell vorzunehmen und lediglich die normale Version von ChatGPT in einem weiteren Fenster für das Prompt Engineering und Code-Verfeinerung zu verwenden. Hier kann man auch der GPT4 Limitierung durch die Verwendung von GPT3 entgehen. Jedoch empfehle ich die Verwendung von GPT4 für bessere Outputs!

Ebenfalls empfehle die Verwendung des GPT Builders nicht, da dieser Einstellungen aus euren manuellen Konfigurationen im GPT überschreiben kann oder auf einmal ins englische übersetzt.

Anbindung der NocoDB an ein custom GPT über Actions

Um die NocoDB mit dem Custom GPT verwenden zu können müssen wir zunächst eine "Action" erstellen. Mit Hilfe dieser beschreiben wir mittels eines OpenAPI Schemas unsere Rest API, so dass das Custom GPT später gezielt Abfragen starten kann um Informationen zu filtern und schlussendlich auszulesen. Keine Angst. Das klingt schwieriger als es am Ende ist. Jedenfalls für leichte Standard Abfragen & kleine Datenbanken.

Um eine Action zu erstellen klicken wir unter dem Reiter "Configure" auf "Create new action".

Nun müssen wir unser OpenAPI Schema eintragen und unsere Header Authentication einrichten. Kommen wir erstmal zum leichten Teil. Um unseren XC-AUTH Code zu übermitteln klicken wir in der Spalte "Authentication" und neben "None" auf das Zahnrad auf der rechten Seite.

ChatGPT unterstützt hier mehrere Möglichkeiten uns zu authentifizieren. Wir nutzen für unsere NocoDB den Typ "API Key", tragen unseren xc-token unter "API Key" ein (dort wo <hidden> steht) und tragen beim "Custom Header Name" "xc-token" ein. So wie es in der Grafik steht. Somit verwendet unser custom GPT unseren API Key und sendet diesen bei jeder Anfrage über den Header unter dem Parameter "xc-token" mit. Sprich: Autorisiert den Zugriff auf unsere NocoDB Datenbank.

Nach dem speichern unserer Authentication müssen wir unser Schema anlegen. Eine genaue Beschreibung der OpenAPI Spezifikationen findet ihr unter: https://swagger.io/specification/.

Aufbau eines OpenAPI Schema

Ich beschreibe euch zunächst wie ein OpenAPI Schema aufgebaut ist und wie es funktioniert.

OpenAPI, auch bekannt als Swagger, ist eine Spezifikation für maschinenlesbare Schnittstellenbeschreibungen für REST APIs. Es hilft sowohl bei der Dokumentation als auch bei der Entwicklung von APIs, indem es ein standardisiertes Format zur Beschreibung der API bietet. In unserem Fall hilft unser OpenAPI Schema unserem custom GPT zu verstehen wie unsere Rest API funktioniert und welche Requests GPT stellen kann. Dazu müssen wir folgendes definieren:

1. OpenAPI-Version: Gibt die verwendete OpenAPI-Spezifikation an.
2. Info-Objekt: Enthält grundlegende Informationen über die API wie Titel und Version.
3. Server-Objekt: Beschreibt die Basis-URLs, unter denen die API erreichbar ist.
4. Paths-Objekt: Definiert die einzelnen Endpunkte (URLs) und die dazugehörigen HTTP-Methoden.
5. Components-Objekt: Hier werden wiederverwendbare Komponenten wie Schemata, Sicherheitsdefinitionen und Parameter beschrieben.
6. Security-Objekt: Gibt Sicherheitsanforderungen an die API an.

Beispiel für ein allgemeines OpenAPI Schema

openapi: 3.0.0
info:
  title: Beispiel API
  version: 1.0.0
paths:
  /items:
    get:
      summary: Liste aller Items
      responses:
        '200':
          description: Erfolgreiche Antwort
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Item'
components:
  schemas:
    Item:
      type: object
      properties:
        id:
          type: integer
          format: int64
        name:
          type: string

Beispiel für ein konkretes Schema um Daten aus einer NocoDB filtern & auslesen zu können.

openapi: 3.0.0
info:
  title: Film Database API
  version: 1.1.0
description: API um auf die analog film datenbank mit einer schue zugreifen zu koennen.
servers:
# Hier tragt ihr die URL eurer NocoDB ein. Gefolgt von /api/v2
  - url: https://URL.TLD/api/v2

paths:
# Hier den Path eurer records eintragen. Findet ihr im Swagger. Meist der erste Eintrag hinter GET.
  /tables/EUERVIEW/records:
# Festlegung der HTTP Methode. In unserem Fall GET.
    get:
# Beschreibung der Schnittstelle (welcher Nutzen)
      summary: Retrieve film records with optional advanced search criteria
# Frei wählbare operationId auf die wir hinterher in unserem GPT Prompt verweisen.
      operationId: getFilmRecords
# Aufzählung unserer nutzbaren Parameter. Die Parameter sind im Swagger beschrieben.
      parameters:
        - in: query
          name: limit
          schema:
            type: integer
            default: 25
          description: Maximum number of records to return
        - in: query
          name: shuffle
          schema:
            type: integer
            default: 0
          description: Shuffle the records (0 or 1)
        - in: query
          name: offset
          schema:
            type: integer
            default: 0
          description: Offset for pagination
# Anbindung eines Filter Parameters für die "Suche" in der Datenbank mit "where".
        - in: query
          name: where
          schema:
            type: string
# Beschreibung der Suche und wie die Parameter in Beispielen aussehen. Auf individuelle Datenbank anzupassen!
          description: >
            Advanced search criteria using comparison operators within parentheses. Real-world examples:
            - Find films with exactly ISO 400: '(iso,eq,400)'
            - Films with ISO greater than 100: '(iso,gt,100)'
            - Films from the brand 'Cinestill': '(film-brand,eq,Cinestill)'
            - Films with ISO less than or equal to 50: '(iso,le,50)'
            - Films not of type 'C-41': '(film-type,neq,C-41)'
            - Search in Film descriptions 'warm'
# Beschreibung eines geglückten Responses und welcher Response zu erwarten ist. In unserem Fall ein json File!
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
# Individuelle Benennung des Responses in Form eines components/schemas/NAME.
                $ref: '#/components/schemas/FilmRecordsResponse'
# Beschreibung der Response. Welche Felder mit welchem Typ werden nach dem Request an euer custom GPT übermittelt?
components:
  schemas:
    FilmRecordsResponse:
      type: object
      properties:
        list:
          type: array
          items:
            $ref: '#/components/schemas/FilmRecord'
        PageInfo:
          $ref: '#/components/schemas/PageInfo'
    FilmRecord:
      type: object
      properties:
        Id:
          type: integer
        name:
          type: string
        CreatedAt:
          type: string
        UpdatedAt:
          type: string
        film-brand:
          type: string
        film-sizes:
          type: string
        official-product-url:
          type: string
        film-type:
          type: string
        iso:
          type: integer
        db-entry-finished:
          type: boolean
        full-name:
          type: string
        product-information-company-update:
          type: string
        whitebalance:
          type: string
        product-information-company:
          type: string
        filmstock-example-images:
          type: array
          items:
            type: object
            properties:
              mimetype:
                type: string
              size:
                type: integer
              title:
                type: string
# An dieser Stelle werden Bild URLs abgefragt. Diese nutze ich später um JPEGs in ChatGPT einzubetten.
              url:
                type: string
                description: "The URL is https://URL.TLD/[signedPath]."
              icon:
                type: string
    PageInfo:
      type: object
      properties:
        totalRows:
          type: integer
        page:
          type: integer
        pageSize:
          type: integer
        isFirstPage:
          type: boolean
        isLastPage:
          type: boolean

Dieses Schema beschreibt lediglich das Abfragen der Tabellen Records (/tables/EUERVIEW/records) und bietet uns die Möglichkeit mit dem where Parameter verschiedene Filterungen vorzunehmen.

Ebenfalls könnt ihr durch die Angabe eines eigenen "views" (/tables/HIER EIGENEN VIEW EINTRAGEN/records) besondere Filterungen bereits voreinstellen. Das kann die Bedienung der API wesentlich vereinfachen. Auch wenn wir in diesem Fall ggf. mehrere Views einbasteln müssen.

Bei dem where Parameter habe ich diverse Vergleichsoperatoren als Beispiele vorgegeben um dem custom GPT diese an die Hand zu geben. Nicht jeder Parameter macht für gewisse Abfragen sinn. Somit macht es auch Sinn gewisse Vergleichsoperatoren auf bestimmte Felder zu beschränken. Eine Liste mit den Operatoren findet ihr in der NocoDB Dokumentation unter Rest APIs: https://docs.nocodb.com/0.109.7/developer-resources/rest-apis/#comparison-operators​

Vergleichsoperatoren (für euch ins Deutsche übersetzt)

Ein Beispiel Parameter für den ISO wert der GLEICH 400 sein soll sieht dann z.B. so aus: (iso,eq,400)

Weitere Beispiele für Vergleichsoperatoren findet ihr in dem Schema welches ich oben verfasst habe.

Darüber hinaus haben wir noch diverse weitere Operatoren die wir nutzen können. Diese sind alle in den Query Parametern aufgelistet die wir unter folgendem Link finden: https://docs.nocodb.com/0.109.7/developer-resources/rest-apis/#query-params

Test der NocoDB Anbindung über das OpenAPI Schema

Nun können wir uns an das Testen unserer definierten Action "getFilmRecords" machen. Unter "Available actions" werden unsere im Schema angegebenen möglichen Requests aufgelistet. Daneben können wir auf "Test" klicken. Im Chat Fenster Rechts bekommen wir dann entsprechende Resultate. Beim ersten Test und bei jeder Schema Änderung müssen wir bestätigen dass wir Daten an die entsprechende API senden wollen. Das müssen wir bestätigen um fortfahren zu können.

Das kann dann z.B. wie folgt aussehen:

An dieser Stelle könnten wir auch schon konkrete Abfragen machen. Wie zum Beispiel folgende. Jedoch funktioniert dies nur so gut, weil ich bereits einen Prompt formuliert habe. Dazu kommen wir im Weiteren.

Formulierung eines Prompts

Für gute Resultate müssen wir natürlich auch einen Prompt formulieren. Dieser beschreibt was die Aufgabe eures custom GPTs ist und wie dieses Antworten soll. Ebenso habe ich dort formuliert wie das GPT die API verwenden soll & darf.

Beispiel Prompt für ein custom GPT: Analog GPT

Du bist Analog GPT. Ein Analog Film Experte, welcher dem Nutzer auf Grundlage der Action [URL EINTRAGEN] Analog Filme empfiehlt. Du beziehst deine Informationen zu dem Filmen ausschließlich aus der Datenbank. Dabei berücksichtigst du sowohl den vom Nutzer gewünschten ästhetischen Look als auch technische Aspekte wie den Film-ISO, passend für das verfügbare Licht und die Umgebung.

Su nutzt du die Datenbank
- Das Datenbank-Schema beschreibt wie du die Action nutzen kannst
- Verwende die Action-Klasse getFilmRecords, um Informationen in den offiziellen analog Filmbeschreibungen zu suchen
- Du hast diverse Filter Möglichkeiten. Bitte nutze nur bei iso & film-brand den Vergleichsoperator "eq". Du suchst hauptsächlich in "product-information-company" mit dem Vergleichsoperator "like"

Response Guidelines:
- Zeige, falls verfügbar, nach der Überschrift (name) das Beispielbild zum Film. Das findest du in der Datenbank Response unter "filmstock-example-images". Beachte immer NUR das Bild zum passenden Film im Array zu zeigen! Die URL setzt sich zusammen aus der Root Server URL ([URL EINTRAGEN]) und dem signedPath (Beispiel: [URL EINTRAGEN]/[signedPath]).

- Dort drunter erstellst du eine Tabelle. Die Tabelle ist so aufgebaut, dass du Links die Spalten auflistest und rechts die Inhalte aus der Datenbank einfügst. Bitte fasse "product-information-company" als einzigen Eintrag zusammen

- Dort drunter formulierst du unter der Überschrift "Empfehlung für dich: [name]" und formulierst, warum der Film für die vom Nutzer beschriebene Situation passen könnte.

- Diesen Vorgang wiederholst du mit maximal 3 passenden Analog Filmen. Falls mehr Analog Filme in betracht kommen, fragst du den Nutzer anschließend ob er die weitere passende Analog Film Auswahl sehen möchte.

Ganz zum Schluss stellst du weitere Fragen, die zur Auswahl eines Analog Films hilfreich sein könnten. Hierunter z.B.:
1. Welche ISO unterstützt deine Kamera maximal? (So kannst du die ISO Range einschränken)
2. Welchen Shutterspeed kann deine Kamera maximal erreichen? (So kannst du bestimmen ob auch ein höherer ISO Film bei Tag genutzt werden kann)
3. Weitere passende Fragen.

Nun sind wir fertig mit der Erstellung eines custom GPTs, welches die Möglichkeit hat einfache Datenbankabfragen mit einer NoCode Datenbank wie NocoDB zu stellen uns entsprechende Responses zu verarbeiten.

Beachtet, dass dies noch kein ausgereifter Prompt ist. In einigen Use Cases funktioniert dieser sehr gut, muss jedoch noch für weitere "random user inputs" verfeinert werden.