Im Back on Agntbox: Meine Reise mit KI-Tools bis jetzt

Hey zusammen, hier ist Nina, zurück auf agntbox.com!

Ihr wisst ja, es fühlt sich an, als wäre es erst gestern gewesen, als ich meiner Tante Maria erklären wollte, was ein “neural network” überhaupt ist (Spoiler: Es lief nicht gut). Ein paar Monate später ist KI praktisch überall. Von der Hilfe beim Entwurf von E-Mails bis hin zur Generierung von Bildern für meine lächerlichen D&D-Kampagnen, diese Tools erleichtern unser Leben, nun ja, einfacher. Aber mit so vielen Optionen, die täglich auftauchen, ist es leicht, im Lärm verloren zu gehen. Und ehrlich gesagt, viele von ihnen versprechen das Blaue vom Himmel, liefern aber… einen kleinen, leicht entleerten Ballon.

Daher möchte ich heute über etwas sprechen, mit dem ich in den letzten Monaten experimentiert habe, etwas, das tatsächlich sein Versprechen hält: OpenAI’s Function Calling API. Genauer gesagt, wie es meine Denkweise beim Erstellen wirklich interaktiver KI-Anwendungen verändert, indem es über die bloße Textgenerierung hinausgeht und tatsächliche, nützliche Aktionen ausführt. Vergesst die klobigen Chatbots von früher; hier reden wir von KI, die Absichten verstehen kann und dann Dinge in der realen Welt (oder zumindest in der Welt eurer Anwendung) tut.

Ich erinnere mich, dass ich vor ein paar Jahren versucht habe, einen einfachen Wetterbot zu erstellen. Es gab endlose Regex-Ausdrücke, bedingte Anweisungen und ein Gebet, dass der Nutzer genau das eingeben würde, was ich erwartet hatte. Es war ein Albtraum. Die Function Calling API? Im Vergleich dazu fühlt es sich wie Magie an. Lass uns eintauchen.

Über das Reden hinaus: Warum Function Calling wichtig ist

Denkt mal darüber nach: Die meisten KI-Modelle sind hervorragend darin, natürliche Sprache zu verstehen und menschenähnlichen Text zu generieren. Das ist fantastisch für das Schreiben von Blogbeiträgen (nicht diesen hier, offensichtlich, das bin ganz ich!), das Zusammenfassen von Dokumenten oder das Brainstormen von Ideen. Aber was, wenn ihr möchtet, dass eure KI tatsächlich mit externen Systemen interagiert? Was, wenn ihr wollt, dass sie:

• einen Flug nachschlägt?
• einen Kaffee bestellt?
• bestimmte Daten aus einer Datenbank abruft?
• eine E-Mail sendet?

Hier stoßen traditionelle textbasierte Modelle an ihre Grenzen. Sie können euch sagen, wie ihr etwas tun könnt, aber sie können es nicht tatsächlich selbst tun. Diese Lücke ist genau das, was die Function Calling API von OpenAI zu schließen versucht. Sie ermöglicht es euch, die verfügbaren Funktionen dem Modell zu beschreiben, und das Modell entscheidet dann, ob und wann es eine dieser Funktionen basierend auf der Eingabe des Nutzers aufruft.

Das Schöne daran ist, dass die KI die Funktion nicht selbst ausführt. Stattdessen generiert sie ein strukturiertes JSON-Objekt, das eurer Anwendung mitteilt, welche Funktion aufzurufen ist und mit welchen Argumenten. Eure Anwendung nimmt dieses JSON dann, führt die tatsächliche Funktion aus und speist das Ergebnis wieder an die KI zurück. Das schafft einen leistungsstarken Kreislauf: Nutzer -> KI (identifiziert Funktion) -> Eure App (führt Funktion aus) -> KI (verarbeitet Ergebnis) -> Nutzer (erhält Antwort/Bestätigung).

Mein “Aha!” Moment: Ein Smart Home Szenario

Mein persönlicher “Aha!” Moment mit Function Calling kam, als ich versuchte, mein Smart Home Setup ein wenig intelligenter zu machen. Ich habe eine Menge Philips Hue-Lampen, ein Smart-Thermostat und ein paar smarte Steckdosen. Ich habe eine einfache Flask-App gebaut, die diese Geräte als API-Endpunkte bereitstellt. Vor Function Calling hatte ich ein wackeliges System von Schlüsselwörtern, die bestimmte Aktionen auslösten. “Wohnzimmerlicht einschalten” funktionierte, aber “Hey, es ist hier ein wenig dunkel, kannst du das Wohnzimmer heller machen?” brachte nur einen leeren Blick von meiner App.

Mit Function Calling habe ich Funktionen wie set_light_brightness(room: str, brightness: int) oder adjust_thermostat(temperature: int) definiert. Ich habe diese dem OpenAI-Modell beschrieben. Jetzt, wenn ich sage, “Es ist hier ein wenig dunkel, kannst du das Wohnzimmer heller machen?”, erkennt das Modell richtig, dass ich set_light_brightness für das “Wohnzimmer” verwenden möchte und könnte sogar einen standardmäßigen “Helligkeits”-Wert ableiten oder um Klarstellung bitten. Es ist eine subtile, aber tiefgreifende Veränderung, wie natürlich die Interaktion sich anfühlt.

Wie es funktioniert: Ein kurzer Einblick (kein Tiefend, versprochen)

Die Grundidee ist ziemlich einfach. Ihr stellt dem OpenAI-Modell eine Liste von Funktionen zur Verfügung, die eure Anwendung ausführen kann, zusammen mit ihren Parametern. Ihr beschreibt diese Funktionen mithilfe eines JSON-Schemas, das ein Standardweg ist, die Struktur von JSON-Daten zu beschreiben. Denkt daran, wie zu einem Bauplan für eure Funktionen.

Wenn ihr die Nachricht eines Nutzers an das Modell sendet, schickt ihr auch diese Liste von Funktionen. Das Modell analysiert dann die Nachricht des Nutzers und entscheidet, ob eine eurer Funktionen nützlich wäre, um die Absicht des Nutzers zu adressieren. Wenn es sich entscheidet, eine Funktion aufzurufen, gibt es eine Nachricht zurück, die den Namen der Funktion enthält, die aufgerufen werden soll, sowie die Argumente, die übergeben werden sollen, alles in einem strukturierten JSON-Format.

Praktisches Beispiel: Ein einfaches Wetter-Tool

Lass uns ein super einfaches Beispiel durchgehen: ein Wetter-Tool. Stellt euch vor, ihr habt einen API-Endpunkt, der Wetterdaten für eine gegebene Stadt abrufen kann.

Zuerst würdet ihr eure Funktion definieren. In Python könnte das folgendermaßen aussehen:

def get_current_weather(location: str, unit: str = "fahrenheit"):
 """
 Holt das aktuelle Wetter an einem bestimmten Standort.
 
 Args:
 location (str): Die Stadt und der Bundesstaat, z. B. San Francisco, CA
 unit (str, optional): Die Temperatureinheit. Kann 'celsius' oder 'fahrenheit' sein. Standardmäßig 'fahrenheit'.
 
 Returns:
 dict: Ein Dictionary mit Wetterinformationen.
 """
 # In einer echten Anwendung würdet ihr hier eine externe Wetter-API aufrufen
 if location == "Boston, MA":
 return {"location": "Boston, MA", "temperature": "50", "unit": unit, "forecast": "cloudy"}
 elif location == "San Francisco, CA":
 return {"location": "San Francisco, CA", "temperature": "68", "unit": unit, "forecast": "sunny"}
 else:
 return {"location": location, "temperature": "N/A", "unit": unit, "forecast": "unknown"}

Als nächstes beschreibt ihr diese Funktion zu OpenAI mithilfe eines JSON-Schemas. Das sagt dem Modell, was die Funktion macht, welche Argumente sie nimmt und deren Typen.

functions = [
 {
 "name": "get_current_weather",
 "description": "Holt das aktuelle Wetter an einem bestimmten Standort",
 "parameters": {
 "type": "object",
 "properties": {
 "location": {
 "type": "string",
 "description": "Die Stadt und der Bundesstaat, z. B. San Francisco, CA",
 },
 "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]},
 },
 "required": ["location"],
 },
 }
]

Jetzt, wenn ein Nutzer fragt: “Wie ist das Wetter in Boston?”, würdet ihr dies an die OpenAI API senden:

import openai

# Angenommen, ihr habt euren OpenAI API-Schlüssel eingerichtet

messages = [{"role": "user", "content": "Wie ist das Wetter in Boston?"}]

response = openai.chat.completions.create(
 model="gpt-3.5-turbo-0613", # Oder gpt-4-0613 für bessere Ergebnisse
 messages=messages,
 functions=functions,
 function_call="auto", # Das sagt dem Modell, eine Funktion aufzurufen, wenn es denkt, es sei angemessen
)

response_message = response.choices[0].message

Das response_message Objekt wird ein function_call Attribut enthalten. Es wird keine direkte Textantwort sein. Stattdessen wird es ungefähr so aussehen:

{
 "role": "assistant",
 "function_call": {
 "name": "get_current_weather",
 "arguments": "{\n \"location\": \"Boston, MA\"\n}"
 }
}

Eure Anwendung analysiert das dann, ruft eure get_current_weather Funktion mit location="Boston, MA" auf und erhält das Ergebnis. Dann speist ihr dieses Ergebnis wieder an das OpenAI-Modell:

# Angenommen, 'response_message' ist die oben genannte
if response_message.function_call:
 function_name = response_message.function_call.name
 function_args = json.loads(response_message.function_call.arguments)

 # Führt die Funktion aus
 function_response = get_current_weather(
 location=function_args.get("location"),
 unit=function_args.get("unit")
 )

 # Fügt den Funktionsaufruf und dessen Antwort zur Nachrichtenhistorie hinzu
 messages.append(response_message) # Der Funktionsaufruf des Assistenten
 messages.append(
 {
 "role": "function",
 "name": function_name,
 "content": json.dumps(function_response),
 }
 )

 # Holt eine neue Antwort vom Modell, jetzt mit der Ausgabe der Funktion
 second_response = openai.chat.completions.create(
 model="gpt-3.5-turbo-0613",
 messages=messages,
 )
 print(second_response.choices[0].message.content)

Und das ist der Moment, in dem ihr eine natürliche Sprachantwort wie “Das aktuelle Wetter in Boston, MA beträgt 50 Grad Fahrenheit und ist bewölkt.” erhaltet.

Meine Erfahrung: Das Gute, Die Eigenheiten und was ich gelernt habe

Die Nutzung von Function Calling hat wirklich verändert, wie ich beim Erstellen von KI-gestützten Funktionen vorgehe. Es fühlt sich weniger danach an, zu raten, was der Nutzer möchte, und mehr danach, die KI zu führen, damit sie versteht und handelt.

Das Gute:

• Reduzierter Prompt Engineering: Im Ernst, das ist ein großer Punkt. Anstatt aufwändige Prompts zu schreiben, um die KI in ein bestimmtes Ausgabeformat zu zwingen oder zu hoffen, dass sie versteht, was zu tun ist, gebt ihr ihr einfach die Werkzeuge (eure Funktionen) und lasst sie entscheiden.
• Erhöhte Genauigkeit bei der Absicht: Das Modell ist überraschend gut darin, herauszufinden, welche Funktion aufzurufen ist, selbst bei mehrdeutigen Formulierungen. Das macht die Benutzererfahrung viel reibungsloser.
• Strukturierte Ausgaben: Ein JSON-Objekt für Funktionsaufrufe zurückzubekommen, ist ein Traum für Entwickler. Keine Mühe mehr, natürliche Sprache in strukturierte Daten zu parsen.
• Erweiterbarkeit: Wenn eure Anwendung wächst, fügt ihr einfach weitere Funktionsdefinitionen hinzu. Die Kernlogik für die Interaktion mit der KI bleibt weitgehend gleich.

Die Eigenheiten (und wie ich damit umgegangen bin):

• Übermäßige Funktionsaufrufe: Manchmal kann das Modell etwas zu eifrig sein, eine Funktion aufzurufen, selbst wenn eine einfache Textantwort ausreichen würde. Ich habe festgestellt, dass es hilfreich ist, sehr genau in meinen Funktionsbeschreibungen zu sein und eindeutige Beispiele in der anfänglichen Aufforderung des Modells hinzuzufügen (falls erforderlich). Außerdem kannst du function_call="none" setzen, um Funktionsaufrufe ausdrücklich zu verhindern, oder function_call={"name": "my_function"} verwenden, um einen bestimmten Funktionsaufruf zu erzwingen.
• Argumentenkonflikt: Das Modell versucht manchmal, eine Funktion mit Argumenten aufzurufen, die nicht ganz deinem Schema entsprechen, oder es erfindet Argumente. Dies passiert normalerweise, wenn die Funktionsbeschreibung nicht ganz klar ist. An der description der Funktion und ihren parameters zu arbeiten, ist entscheidend.
• Der Multi-Turn Tanz: Denk daran, dass du ein Gespräch aufbaust. Nachdem deine App eine Funktion ausgeführt hat, musst du das Ergebnis als Nachricht in der Rolle „funktion“ zurück an das Modell füttern. Wenn du das vergisst, brichst du den Gesprächsfluss und die KI weiß nicht, was passiert ist. Dies war anfangs ein häufiger Fehler für mich.
• Kostenüberlegungen: Jeder Schritt im Gespräch, insbesondere wenn Funktionen beteiligt sind, verbraucht Tokens. Wenn du viele Funktionen oder sehr ausführliche Funktionsergebnisse hast, kann sich das summieren. Sei dir der Länge deiner Funktionsbeschreibungen und der Daten, die du aus deinen Funktionen zurückgibst, bewusst.

Eine spezifische Erkenntnis: Wenn du deine Funktionen beschreibst, liste nicht nur die Parameter auf. Erkläre weshalb jemand diese Funktion verwenden würde und welche Art von Eingabe sie erwartet. Zum Beispiel, anstatt nur location: str zu sagen, formuliere location: Die Stadt und der Bundesstaat, z.B. 'San Francisco, CA' oder 'New York City, NY'. Diese kleinen Details machen einen großen Unterschied darin, wie genau das Modell die Benutzerabsicht interpretiert.

Handlungsanweisungen für dein nächstes KI-Projekt

Wenn du etwas baust, das über einfache Textgenerierung hinausgeht, empfehle ich dringend, die Function Calling API von OpenAI zu erkunden. Hier sind meine Vorschläge:

1. Starte einfach: Versuche nicht, alle API-Endpunkte auf einmal zu integrieren. Wähle ein oder zwei zentrale Aktionen, die deine KI ausführen können soll, und definiere dafür Funktionen.
2. Sei klar in deinen Funktionsbeschreibungen: Betrachte deine Funktionsbeschreibungen als Mini-Aufforderungen für die KI. Je klarer du beschreibst, was die Funktion tut, ihre Parameter und Beispiele für gültige Eingaben, desto besser wird das Modell funktionieren.
3. Gehe freundlich mit Fehlern um: Deine externen Funktionen können fehlschlagen. Stelle sicher, dass deine Anwendung diese Fehler abfangen und eine hilfreiche Fehlermeldung an die KI (und anschließend an den Benutzer) übermitteln kann. Die KI kann sich dann entschuldigen oder Alternativen vorschlagen.
4. Achte auf das Kontextfenster: Denk daran, dass die gesamte Gesprächshistorie, einschließlich der Funktionsaufrufe und ihrer Ergebnisse, zum Kontextfenster des Modells zählt. Bei langen, komplexen Interaktionen benötigst du möglicherweise Strategien zur Verwaltung des Kontexts (z. B. das Zusammenfassen vergangener Schritte).
5. Teste, teste, teste: Teste deine Funktionen mit verschiedenen Benutzeraufforderungen, einschließlich mehrdeutiger, um zu sehen, wie das Modell sie interpretiert. Dieser iterative Prozess ist entscheidend für die Verfeinerung deiner Funktionsbeschreibungen.

Function Calling ist ein bedeutender Schritt nach vorn, um KI-Assistenten wirklich nützlich und interaktiv zu machen. Es bringt uns näher an eine Zukunft, in der KI nicht nur ein Gesprächspartner, sondern ein fähiger Agent ist, der uns hilft, Dinge zu erledigen. Probiere es aus – vielleicht bemerkst du, dass sich auch dein Ansatz zur KI-Entwicklung ändert.

Bis zum nächsten Mal, bleib dran und baue coole Sachen!

Nina

🕒 Published: March 27, 2026