Funktionsaufrufe

Verwenden Sie den Funktionsaufruf, damit das Modell Daten oder Aktionen aus Ihrer Anwendung während eines API-Workflow für Antworten anfordert. Dies ist nützlich, wenn das Modell Informationen oder Vorgänge benötigt, die nicht im Prompt selbst verfügbar sind, z.B. Kalenderdaten, interner Anwendungsstatus oder das Ergebnis eines benutzerdefinierten Vorgangs.

Mit diesem Muster führt das Modell die Funktion nicht direkt aus. Stattdessen werden der Funktionsname und die Argumente zurückgegeben, die Anwendung führt die Funktion aus, und dann sendet die Anwendung die Funktionsausgabe zurück, damit das Modell fortfahren und die benutzerorientierte Antwort erzeugen kann.

Was dies ermöglicht

Funktionsaufrufe sind nützlich, wenn Ihre Anwendung die Kontrolle über die Ausführung behalten muss und das Modell dennoch entscheiden kann, wann externe Informationen benötigt werden.

Beispiele für Anwendungsfälle:

Kalenderereignisse suchen
Anwendungsdaten werden abgerufen...
Interne oder externe API wird aufgerufen
Geschäftslogik oder Berechnungen ausführen

Innerhalb Ihrer Funktion können Sie einen externen Service, eine Datenbank, eine Ihrer eigenen Library-APIs, eine CLI oder einen lokalen MCP-Server aufrufen.

Dieser Ansatz bietet Ihnen Flexibilität, während Sie den Ausführungspfad innerhalb der Anwendung beibehalten.

Ausführungsfluss

Eine typische Funktion, die Interaktion aufruft, funktioniert wie folgt:

Der Client sendet eine Anforderung, die eine oder mehrere Funktionstooldefinitionen enthält.
Das Modell entscheidet, ob eines dieser Werkzeuge benötigt wird.
Wenn ein Tool benötigt wird, gibt das Modell den Funktionsnamen und die Argumente zurück.
Die Anwendung führt die Funktion aus und bereitet das Ergebnis vor.
Die Anwendung sendet dieses Ergebnis in einer Folgeanforderung zurück.
Das Modell verwendet dieses Ergebnis, um die Antwort abzuschließen.

Optionen für die Zustandsbehandlung

Es gibt zwei allgemeine Möglichkeiten, den Status über diese Anforderungen hinweg zu verwalten:

Serviceverwalteter Status

Empfohlen für die meisten Anwendungsfälle. Die Nachfassanforderung enthält previous_response_id, und der Service verfolgt den früheren Austausch.
Client-verwalteter Status

Die Anwendung behält die vollständige Interaktionshistorie bei und sendet den akkumulierten Kontext mit jeder Anforderung.

Tipp

Halten Sie Werkzeugdefinitionen präzise. Klare Namen, gut geschriebene Beschreibungen und gut definierte Parameter helfen dem Modell, das richtige Tool auszuwählen und verwendbare Argumente zu generieren.

Funktionstools definieren

Um ein Funktionstool zu definieren, fügen Sie einen Eintrag in der Eigenschaft tools mit "type": "function" hinzu.

Das folgende Beispiel definiert ein Tool, das Kalenderereignisse für ein bestimmtes Datum abruft:

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

Nehmen Sie dieses tools-Array in die client.responses.create()-Anforderung auf.

Beispiel: Service-verwalteter Status

In diesem Muster lässt die erste Anforderung das Modell entscheiden, ob das Tool benötigt wird. Die zweite Anforderung sendet das Toolergebnis zurück und referenziert die frühere Antwort.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

# Initial request
response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input="Show the calendar events for 2026-04-02.",
)

# Execute the requested function
tool_outputs = []
for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        tool_outputs.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

# Follow-up request
final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=tool_outputs,
    previous_response_id=response.id,
)

print(final.output_text)

Beispiel: Client-verwalteter Status

In diesem Muster behält die Anwendung den vollständigen Austausch bei und leitet ihn mit der Nachfassanforderung erneut weiter.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

conversation = [
    {"role": "user", "content": "Show the calendar events for 2026-04-02."}
]

response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input=conversation,
)

conversation += response.output

for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        conversation.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=conversation,
)

print(final.output_text)

Funktionsaufrufe sind eine starke Option, wenn die Anwendung für die Ausführung, Zugriffskontrolle und Integrationslogik verantwortlich bleiben muss, während das Modell weiterhin die benötigten Informationen anfordern kann.