Ich bin zurück auf Agntbox: mein bisheriger Weg mit dem KI-Tool

Hallo zusammen, ich bin Nina, zurück auf agntbox.com!

Wisst ihr, es kommt mir vor, als hätte ich gestern noch versucht, meiner Tante Maria zu erklären, was ein „neuronales Netzwerk“ ist (spoiler: das ist nicht gut gelaufen). Schnelldurchlauf bis heute, und KI ist praktisch überall. Von der Hilfe beim Verfassen von E-Mails bis zur Generierung von Bildern für meine lächerlichen D&D-Kampagnen machen diese Tools unser Leben, nun ja, einfacher. Aber bei so vielen Optionen, die jeden Tag auftauchen, verliert man leicht den Überblick. Und ganz ehrlich, viele von ihnen versprechen den Mond, liefern aber… nur einen leicht deflatierten Ballon.

Deshalb möchte ich heute über etwas sprechen, mit dem ich seit einigen Monaten experimentiere, etwas, das tatsächlich seine Versprechen gehalten hat: die OpenAI Function Call API. Genauer gesagt, wie sie meine Denkweise zur Erstellung von wirklich interaktiven KI-Anwendungen verändert, indem sie über die reine Textgenerierung hinausgeht und echte, nützliche Aktionen ermöglicht. Vergesst die klobigen Chatbots von damals; wir sprechen über KI, die die Absicht verstehen kann und dann Dinge tun kann, in der realen Welt (oder zumindest in der Welt eurer Anwendung).

Ich erinnere mich, dass ich vor einigen Jahren versucht habe, einen einfachen Wetterbot zu erstellen. Das beinhaltete endlose Regex, bedingte Anweisungen und ein Gebet, dass der Benutzer genau das eintippt, was ich erwartete. Es war ein Albtraum. Die Function Call API? Das ist im Vergleich dazu Magie. Lass uns eintauchen.

Über die Einfache Unterhaltung hinaus: Warum Function Call wichtig ist

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

• Ein Flug sucht?
• Ein Kaffee bestellt?
• Spezifische Daten aus einer Datenbank abruft?
• Eine E-Mail sendet?

Hier erreichen die herkömmlichen Text-zu-Text-Modelle eine Grenze. Sie können euch sagen, wie man etwas macht, aber sie können es nicht tatsächlich selbst tun. Diese Lücke ist genau das, was die OpenAI Function Call API zu schließen versucht. Sie ermöglicht es euch, die verfügbaren Funktionen dem Modell zu beschreiben, und dann entscheidet das Modell, ob und wann eine dieser Funktionen basierend auf der Benutzereingabe aufgerufen werden sollte.

Die Schönheit dabei ist, dass die KI die Funktion nicht tatsächlich selbst ausführt. Stattdessen erzeugt sie ein strukturiertes JSON-Objekt, das eurer Anwendung sagt, welche Funktion aufgerufen werden soll und mit welchen Argumenten. Eure Anwendung nimmt dann dieses JSON, führt die tatsächliche Funktion aus und gibt das Ergebnis an die KI zurück. Das schafft eine mächtige Schleife: Benutzer -> KI (identifiziert die Funktion) -> Eure App (führt die Funktion aus) -> KI (verarbeitet das Ergebnis) -> Benutzer (erhält eine Antwort/Bestätigung).

Mein „Aha!“ Moment: Ein Smart Home Szenario

Mein persönlicher „Aha!“ Moment mit dem Function Call kam, als ich versuchte, meine Smart Home Einrichtung ein wenig intelligenter zu machen. Ich habe eine Menge Philips Hue Lichter, einen intelligenten Thermostat und ein paar intelligente Steckdosen. Ich habe eine einfache Flask-App erstellt, die diese Geräte als API-Endpunkte verfügbar macht. Vor dem Function Call hatte ich ein wackeliges System von Schlüsselwörtern, die spezifische Aktionen auslösten. „Schalte die Lichter im Wohnzimmer ein“ funktionierte, aber „Hey, es ist hier ein bisschen dunkel, kannst du das Wohnzimmer heller machen?“ brachte meiner App nur einen leeren Blick ein.

Mit dem Function Call habe ich Funktionen wie set_light_brightness(room: str, brightness: int) oder adjust_thermostat(temperature: int) definiert. Ich habe sie dann dem OpenAI Modell beschrieben. Jetzt, wenn ich sage: „Es ist hier ein bisschen dunkel, kannst du das Wohnzimmer heller machen?“, identifiziert das Modell korrekt, dass ich set_light_brightness für das „Wohnzimmer“ verwenden will und könnte sogar einen Standardwert für „Helligkeit“ ableiten oder nach Klarstellungen fragen. Das ist eine subtile, aber tiefgreifende Veränderung in der Art und Weise, wie die Interaktion natürlich erscheint.

Wie es funktioniert: Ein schneller Überblick (Keine Tiefe, verspreche ich)

Die Grundidee ist ziemlich einfach. Ihr gebt dem OpenAI Modell eine Liste von Funktionen, die eure App durchführen kann, sowie deren Parameter. Ihr beschreibt diese Funktionen mit einem JSON-Schema, das eine standardisierte Weise ist, die Struktur von JSON-Daten zu beschreiben. Denkt daran, es ist wie ein Plan für eure Funktionen.

Wenn ihr eine Benutzermeldung an das Modell sendet, schickt ihr auch diese Liste von Funktionen mit. Das Modell analysiert dann die Benutzermeldung und entscheidet, ob eine eurer Funktionen hilfreich wäre, um die Absicht des Benutzers zu erfüllen. Wenn es entscheidet, eine Funktion aufzurufen, sendet es eine Nachricht mit dem Namen der Funktion, die aufgerufen werden soll, und den Argumenten, die ihm übergeben werden sollen, alles in einem strukturierten JSON-Format.

Praktisches Beispiel: Ein Einfaches Wettertool

Lassen Sie uns ein super einfaches Beispiel durchgehen: ein Wettertool. Stellt euch vor, ihr habt einen API-Endpunkt, der Wetterdaten für eine bestimmte Stadt abrufen kann.

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

def get_current_weather(location: str, unit: str = "fahrenheit"):
 """
 Holt sich das aktuelle Wetter an einem gegebenen Standort.

 Args:
 location (str): Die Stadt und der Staat, 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"}

Danach beschreibt ihr diese Funktion mit einem JSON-Schema an OpenAI. Das gibt dem Modell an, was die Funktion macht, welche Argumente sie nimmt, und deren Typen.

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

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

import openai

# Vorausgesetzt, ihr habt euren OpenAI API-Schlüssel konfiguriert

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 gibt dem Modell an, eine Funktion aufzurufen, wenn es denkt, es ist angebracht
)

response_message = response.choices[0].message

Das Objekt response_message wird ein Attribut function_call enthalten. Dies wird keine direkte textuelle Antwort 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 dann dies, ruft eure Funktion get_current_weather mit location="Boston, MA" auf und erhält das Ergebnis. Dann gebt ihr dieses Ergebnis an das OpenAI Modell zurück:

# Angenommen, 'response_message' ist der obenstehende
if response_message.function_call:
 function_name = response_message.function_call.name
 function_args = json.loads(response_message.function_call.arguments)

 # Funktion ausführen
 function_response = get_current_weather(
 location=function_args.get("location"),
 unit=function_args.get("unit")
 )

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

 # Holen Sie sich 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 Sie eine natürliche Antwort erhalten wie: „Das aktuelle Wetter in Boston, MA ist 50 Grad Fahrenheit und bewölkt.“

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

Die Verwendung des Funktionsaufrufs hat meine Herangehensweise an den Aufbau von KI-unterstützten Funktionen wirklich verändert. Es fühlt sich weniger nach einem Rätsel an, was der Benutzer will und mehr danach, die KI zu leiten, um zu verstehen und zu handeln.

Das Gute:

• Reduzierung des Prompt-Engineerings: Ernsthaft, das ist ein großer Punkt. Anstatt ausgeklügelte Eingaben zu schreiben, um die KI in ein bestimmtes Ausgabeformat zu zwingen oder zu hoffen, dass sie versteht, was zu tun ist, geben Sie ihr einfach die Werkzeuge (Ihre Funktionen) und lassen sie entscheiden.
• Erhöhte Genauigkeit für die Absicht: Das Modell ist erstaunlich gut darin, zu bestimmen, welche Funktion aufzurufen ist, selbst bei mehrdeutigen Formulierungen. Das macht das Benutzererlebnis viel flüssiger.
• Strukturierte Ausgaben: Ein JSON-Objekt für Funktionsaufrufe zu erhalten, ist ein Traum für Entwickler. Es gibt keine Notwendigkeit mehr, natürliche Sprache in strukturierte Daten zu transformieren.
• Erweiterbarkeit: Während Ihre Anwendung wächst, fügen Sie einfach mehr Funktionsdefinitionen hinzu. Die grundlegende Logik für den Umgang mit der KI bleibt weitgehend gleich.

Die Eigenheiten (und wie ich damit umgegangen bin):

• Übermäßige Funktionsaufrufe: Manchmal kann das Modell etwas zu eilig sein, eine Funktion aufzurufen, selbst wenn eine einfache textliche Antwort genügt. Ich habe festgestellt, dass es hilft, sehr präzise in meinen Funktionsbeschreibungen zu sein und klare Beispiele in den ersten Prompt des Modells aufzunehmen (falls erforderlich). Sie können auch function_call="none" festlegen, um ausdrücklich Funktionsaufrufe zu verhindern, oder function_call={"name": "my_function"}, um einen spezifischen Funktionsaufruf zu erzwingen.
• Argumentinkompatibilität: Das Modell kann manchmal versuchen, eine Funktion mit Argumenten aufzurufen, die nicht wirklich Ihrem Schema entsprechen, oder Argumente erfinden. Das passiert normalerweise, wenn die Funktionsbeschreibung nicht perfekt klar ist. Es ist wichtig, die description der Funktion und ihre parameters zu bearbeiten.
• Der Multi-Turn-Tanz: Denken Sie daran, dass Sie ein Gespräch führen. Nachdem Ihre Anwendung eine Funktion ausgeführt hat, müssen Sie das Ergebnis in Form einer Nachricht mit der Rolle „Funktion“ an das Modell zurückgeben. Wenn Sie dies vergessen, bricht der Gesprächsfluss und die KI weiß nicht, was passiert ist. Das war zu Beginn ein häufiger Fehler für mich.
• Kostenüberlegungen: Jeder Gesprächszyklus, insbesondere bei Funktionen, verbraucht Tokens. Wenn Sie viele Funktionen oder sehr ausführliche Funktionsergebnisse haben, kann das sich summieren. Achten Sie auf die Länge Ihrer Funktionsbeschreibungen und die Daten, die Sie von Ihren Funktionen zurückgeben.

Eine spezifische Erkenntnis: Wenn Sie Ihre Funktionen beschreiben, beschränken Sie sich nicht nur auf die Auflistung der Parameter. Erklären Sie warum jemand diese Funktion verwenden würde und welche Art von Eingabe sie erwartet. Zum Beispiel, anstatt einfach location: str zu sagen, sagen Sie location: Die Stadt und der Staat, zum Beispiel 'San Francisco, CA' oder 'New York City, NY'. Diese kleinen Details beeinflussen, wie das Modell die Absicht des Benutzers interpretiert, erheblich.

Feedback für Ihr nächstes KI-Projekt

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

1. Einfach anfangen: Versuchen Sie nicht, alle API-Endpunkte gleichzeitig zu integrieren. Wählen Sie ein oder zwei Hauptaktionen, die Ihre KI ausführen soll, und definieren Sie dafür Funktionen.
2. Seien Sie explizit in Ihren Funktionsbeschreibungen: Betrachten Sie Ihre Funktionsbeschreibungen als Mini-Prompts für die KI. Je klarer Sie beschreiben, was die Funktion tut, ihre Parameter und Beispiele für gültige Eingaben, desto besser wird das Modell funktionieren.
3. Fehler elegant handhaben: Ihre externen Funktionen können fehlschlagen. Stellen Sie sicher, dass Ihre Anwendung in der Lage ist, diese Fehler zu erfassen und eine hilfreiche Fehlermeldung an die KI (und somit an den Benutzer) zurückzugeben. Die KI kann sich dann entschuldigen oder Alternativen vorschlagen.
4. Achten Sie auf das Kontextfenster: Denken Sie daran, dass der gesamte Verlauf des Gesprächs, einschließlich der Funktionsaufrufe und ihrer Ergebnisse, zum Kontextfenster des Modells zählt. Bei langen und komplexen Interaktionen müssen Sie möglicherweise Strategien entwickeln, um den Kontext zu verwalten (z. B. frühere Zyklen zusammenfassen).
5. Testen, testen, testen: Testen Sie Ihre Funktionen mit verschiedenen Benutzerprompts, einschließlich mehrdeutiger, um zu sehen, wie das Modell sie interpretiert. Dieser iterative Prozess ist entscheidend, um Ihre Funktionsbeschreibungen zu verfeinern.

Der Funktionsaufruf ist ein bedeutender Schritt nach vorne, 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 bei der Erledigung von Aufgaben helfen kann. Probieren Sie es aus – Sie könnten feststellen, dass es auch Ihre Herangehensweise an die KI-Entwicklung verändert.

Bis zum nächsten Mal, kreieren Sie weiterhin großartige Dinge!

Nina

🕒 Published: March 30, 2026