Funktionenwerkzeug verwenden

  • 5 Minuten

Mit dem Funktionstool kann Ihr Modell entwicklerdefinierte Funktionen aufrufen, um Daten abzurufen oder Aktionen während einer Antwort auszulösen.

Was ist das Funktionstool?

Mit dem Funktionstool (Funktionsaufruf) kann ein Modell entscheiden, wann benannte Tools aufgerufen werden sollen, die Sie in Ihrer Anwendung verfügbar machen. Das Modell führt Ihre Geschäftslogik nicht direkt aus. Stattdessen wird ein strukturierter Funktionsaufruf zurückgegeben, ihr Code führt die Funktion aus, und anschließend übergeben Sie die Funktionsausgabe an das Modell zurück.

Dieses Muster eignet sich ideal zum Verbinden von Modellgrundgründen mit realen Systemen wie APIs, Datenbanken, Geschäftsworkflows und Hilfsfunktionen.

Zu den wichtigsten Features gehören:

  • Strukturierte Toolaufrufe – Das Modell gibt explizite Funktionsaufrufanforderungen aus.
  • Entwicklergesteuerte Ausführung – Ihre Anwendung entscheidet, wie und wo Funktionen ausgeführt werden
  • Zuverlässiges Integrationsmuster – APIs, interne Dienste oder Hilfsprogramme sicher aufrufen
  • Multi-Turn-Orchestrierung – Rückgabe der Tool-Ausgabe und Fortsetzung des Schlussfolgerungsprozesses durch das Modell
  • Geerdete Antworten – Antworten können live vom System generierte Daten enthalten

Gängige Anwendungsfälle

Anwendungsfall Beispiel
Systemintegration Aufrufen einer internen API für Konto- oder Bestelldetails
Aufgabenautomatisierung Auslösen von Workflows wie Ticketerstellung oder Benachrichtigungen
Datensuche Abfragen von Geschäftsregeln oder Referenztabellen vor der Beantwortung

Ein einfaches Beispiel

Hier ist ein Beispiel, das eine get_time Funktion verfügbar macht, und das Modell kann sie bei Bedarf aufrufen.

import time
from openai import OpenAI

# Function to get the current time
def get_time():
    return f"The time is {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}"


# Main function
def main():
    client = OpenAI(
        base_url={openai_endpoint},
        api_key={auth_key_or_token}
    )

    function_tools = [
        {
            "type": "function",
            "name": "get_time",
            "description": "Get the current time"
        }
    ]

    # Initialize messages with a system prompt
    messages = [
        {"role": "developer", "content": "You are an AI assistant that provides information."},
    ]

    # Loop until the user types 'quit'
    while True:
        prompt = input("\nEnter a prompt (or type 'quit' to exit)\n")
        if prompt.lower() == "quit":
            break

        # Append the user prompt to the messages
        messages.append({"role": "user", "content": prompt})

        # Get initial response
        response = client.responses.create(
            model=model_deployment,
            input=messages,
            tools=function_tools
        )

        # Append model output to the messages
        messages += response.output

        # Was there a function call?
        for item in response.output:
            if item.type == "function_call" and item.name == "get_time":
                current_time = get_time()
                messages.append({
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": current_time
                })

                # Get a follow up response using the tool output
                response = client.responses.create(
                    model=model_deployment,
                    instructions="Answer only with the tool output.",
                    input=messages,
                    tools=function_tools
                )

        print(response.output_text)


# Run the main function when the script starts
if __name__ == '__main__':
    main()

In diesem Ablauf entscheidet das Modell, wann get_time aufgerufen werden soll, Ihr Code führt die Funktion aus, und das Modell gibt dann eine fundierte endgültige Antwort zurück. Da der Benutzer eine beliebige Eingabeaufforderung eingeben kann, muss das Modell bestimmen, wann die Funktion aufgerufen werden muss. Wenn dies der Fall ist, enthält die Antwort auf die Eingabeaufforderung einen Funktionsaufruf, den der Anwendungscode implementieren muss, bevor eine neue Eingabeaufforderung mit der Ausgabe der Funktion für das Zu verarbeitende Modell übermittelt wird.

Die Ausgabe könnte ungefähr so aussehen:

Enter a prompt (or type 'quit' to exit)
Hello

Hello! How can I help you today?

Enter a prompt (or type 'quit' to exit)
What time is it?

The time is 2026-03-19 17:17:41.

Enter a prompt (or type 'quit' to exit)

Die erste Benutzeraufforderung ("Hello") erforderte nicht die Verwendung des Funktionstools, sodass das Modell normal reagierte. Die zweite Eingabeaufforderung ("Wie spät ist es?") löste das Modell aus, um die get_time Funktion auszuwählen, die es in seiner Antwort angab. Der Anwendungscode hat dann die Funktion ausgeführt und die Ergebnisse an das Modell zurückgegeben, die dann eine zweite Antwort mit den Ergebnissen der Funktion gesendet haben.

Tipp

In diesem Beispiel wird eine einzelne Funktion ohne Parameter verwendet. Sie können das Tool so konfigurieren, dass mehrere Funktionen verwendet werden, mit oder ohne Parameter. Weitere Informationen zum Angeben von Funktionsdetails finden Sie im OpenAI-Entwicklerhandbuch.

Funktionsweise des Funktionstools

Der allgemeine Prozess für die Verwendung des Funktionstools lautet:

  1. Sie definieren Tools – Stellen Sie eine oder mehrere Funktionsdefinitionen im Toolsarray bereit.
  2. Das Modell wertet die Eingabeaufforderung aus – Es bestimmt, ob ein Funktionsaufruf erforderlich ist.
  3. Das Modell gibt einen Funktionsaufruf aus – Die Antwort enthält den Funktionsnamen und die Aufrufmetadaten.
  4. Ihre App führt Logik aus – Führen Sie die entsprechende Funktion in Ihrem Code aus.
  5. Sie geben die Funktionsausgabe zurück – Senden Sie ein function_call_output Element mit dem Ergebnis.
  6. Das Modell schließt die Antwort ab – Es enthält Toolergebnisse in die endgültige Antwort.

Bewährte Methoden

  • Konzentrieren Sie sich auf Tools – Kleine, einzweckige Funktionen sind einfacher zu kontrollieren und zu testen
  • Überprüfen von Funktionseingaben – Argumenten von Tools nicht blind in Produktionssystemen vertrauen
  • Sicheres Behandeln von Fehlern – Eindeutige Fehlerausgaben zurückgeben, über die das Modell nachdenken kann
  • Protokolltoolverwendung – Nachverfolgen von Aufrufen, Latenz und Fehlerraten für Debugging und Governance
  • Einschränken vertraulicher Vorgänge – Explizite Autorisierung für Aktionen mit hoher Auswirkung erforderlich

Einschränkungen, die Sie kennen sollten

  • Das Modell fordert Funktionsaufrufe an, ihre Anwendung muss sie jedoch ausführen.
  • Falsche oder unerwartete Toolargumente können auftreten und sollten überprüft werden
  • Die Toollatenz kann die End-to-End-Antwortzeit erhöhen.
  • Funktionsaufrufe verbessern die Zuverlässigkeit, aber die finalen Ergebnisse müssen weiterhin für kritische Entscheidungen überprüft werden.

Gut eingesetzt verwandelt das Funktionstool ein Modell von einem Textgenerator zu einem Orchestrator, der auf kontrollierte und auditierbare Weise mit realen Systemen interagieren kann.