Warum OpenAI Functions?

Weil GPT mittlerweile mehr kann als plaudern.
Mit Functions kannst Du GPT sagen, wann es welche „Funktion“ aufrufen soll.
Du gibst das Schema. GPT wählt die Methode.
Access liefert die Eingaben – und verarbeitet die Rückgaben.

Ich zeig Dir, wie Du in Access ein dynamisches Funktionssystem aufbaust.
Mit VBA, JSON und ein bisschen Hirnschmalz.

Was Du brauchst

• OpenAI API Key
• GPT-4 (funktioniert auch mit 3.5 turbo, wenn gpt-3.5-turbo-0613 oder neuer)
• Funktionsdefinitionen als JSON
• VBA für den Request
• Parsinglogik für die GPT-Antwort

Tabelle: Deine Funktionen verwalten

Tabelle	Zweck
tblFunctions	Funktionsnamen, Beschreibung, Parameterdefinition
tblDialog	Verlauf aus Frage, GPT-Antwort, ggf. Funktionsaufruf

Beispiel: Funktion „rechnungsbetrag_berechnen“

{
  "name": "rechnungsbetrag_berechnen",
  "description": "Berechnet den Gesamtpreis inkl. MwSt",
  "parameters": {
    "type": "object",
    "properties": {
      "netto": { "type": "number", "description": "Nettobetrag in EUR" },
      "mwst":  { "type": "number", "description": "Mehrwertsteuersatz in Prozent" }
    },
    "required": ["netto", "mwst"]
  }
}

Das baust Du per VBA in ein JSON ein. Oder speicherst es als Text in Deiner Tabelle.

VBA: API-Call mit Function Definitions

Function GPTMitFunctions(prompt As String) As String
    Dim http As Object
    Dim json As String
    Dim apiKey As String
    Dim functionDef As String

    apiKey = "DEIN_API_KEY"

    functionDef = LadeFunctionDefinitionAusTabelle("rechnungsbetrag_berechnen")

    json = "{" & _
        """model"":""gpt-4-0613""," & _
        """messages"":[{""role"":""user"",""content"":""" & Replace(prompt, """", "\""") & """}]," & _
        """functions"":[" & functionDef & "]," & _
        """function_call"":""auto""" & _
        "}"

    Set http = CreateObject("MSXML2.ServerXMLHTTP")
    http.Open "POST", "https://api.openai.com/v1/chat/completions", False
    http.setRequestHeader "Content-Type", "application/json"
    http.setRequestHeader "Authorization", "Bearer " & apiKey
    http.send json

    GPTMitFunctions = http.responseText
End Function

Parsing: GPT hat Funktion gewählt

Du musst nun auslesen:

• Funktion (z. B. rechnungsbetrag_berechnen)
• Argumente als JSON-Objekt

Beispielantwort (gekürzt)

{
  "choices": [{
    "message": {
      "function_call": {
        "name": "rechnungsbetrag_berechnen",
        "arguments": "{ \"netto\": 100, \"mwst\": 19 }"
      }
    }
  }]
}

Extrahieren per VBA

Function ExtrahiereFunctionName(json As String) As String
    Dim sc As Object
    Set sc = CreateObject("ScriptControl")
    sc.Language = "JScript"
    sc.AddCode "function fn(j){return JSON.parse(j).choices[0].message.function_call.name;}"
    ExtrahiereFunctionName = sc.Run("fn", json)
End Function

Function ExtrahiereFunctionArgs(json As String) As String
    Dim sc As Object
    Set sc = CreateObject("ScriptControl")
    sc.Language = "JScript"
    sc.AddCode "function args(j){return JSON.parse(j).choices[0].message.function_call.arguments;}"
    ExtrahiereFunctionArgs = sc.Run("args", json)
End Function

Lokale Funktion ausführen

Function BerechneRechnung(netto As Double, mwst As Double) As Double
    BerechneRechnung = netto * (1 + mwst / 100)
End Function

JSON-Parsing mit Access-Mitteln:

Function ParseArgumentsUndBerechne(jsonArgs As String) As String
    Dim sc As Object
    Set sc = CreateObject("ScriptControl")
    sc.Language = "JScript"
    sc.AddCode "function parseArgs(j){var a=JSON.parse(j); return a.netto + '|' + a.mwst;}"
    Dim teile() As String
    teile = Split(sc.Run("parseArgs", jsonArgs), "|")
    ParseArgumentsUndBerechne = CStr(BerechneRechnung(CDbl(teile(0)), CDbl(teile(1))))
End Function

Gesamtablauf im Formular

Sub StarteGPTFunction()
    Dim prompt As String
    Dim antwort As String
    Dim fnName As String
    Dim args As String
    Dim ergebnis As String

    prompt = Me.txtFrage
    antwort = GPTMitFunctions(prompt)

    fnName = ExtrahiereFunctionName(antwort)
    args = ExtrahiereFunctionArgs(antwort)

    If fnName = "rechnungsbetrag_berechnen" Then
        ergebnis = ParseArgumentsUndBerechne(args)
        Me.txtErgebnis = ergebnis
    Else
        MsgBox "Unbekannte Funktion: " & fnName
    End If
End Sub

Was Du damit bauen kannst

Funktionstyp	Beispiel
Preisberechnungen	Netto → Brutto, Rabatte, Skalierung
Datenkonvertierung	Text → JSON, Text → Datum, Einheit umrechnen
Terminplanung	„Plan ein Meeting nächste Woche Dienstag“
Logikprüfungen	GPT prüft Inhalte und ruft je nach Fall etwas auf

Was Du beachten musst

• Funktion muss sauber beschrieben sein (Parameter, Typen)
• Access kennt keine JSON-Objekte → alles als Text parsen
• Funktion muss lokal existieren – GPT ruft nicht „wirklich“ etwas auf
• GPT entscheidet selbst, ob eine Funktion nötig ist oder nicht

„Du definierst die Werkzeuge – GPT entscheidet, wann sie zum Einsatz kommen.“

Wenn Du dynamische GPT-Tools direkt in Access bauen willst:
Meld Dich. Ich helf Dir, das sauber zu strukturieren. Ohne Overkill. Nur Wirkung.