OpenAI Funktionsaufruf

OpenAI Funktionsaufruf V2 Merkmale

Das Hauptziel des Funktionsaufrufs V2 besteht darin, OpenAI-Modellen die Möglichkeit zu geben, mit der Außenwelt zu interagieren, was sich in den folgenden beiden Kernfunktionen widerspiegelt:

1. Daten abrufen - RAGs Funktionsaufruf-Implementierung.
   • Im Wesentlichen RAG (Retrieval Augmented Generation). Funktionsaufrufe bieten einen leistungsfähigen Mechanismus zur Implementierung der Erzeugung von Abruferweiterungen (RAG). Das Modell kann aktuelle und relevante Informationen aus externen Datenquellen (z. B. Wissensdatenbanken, APIs usw.) abrufen, indem es vordefinierte Funktionen aufruft und diese in seine eigenen generierten Antworten einbezieht.
   • Aufarbeitung von Informationsrückständen und Wissenslücken. Das herkömmliche Wissen großer Sprachmodelle ist statisch; der Funktionsaufruf überbrückt diese Lücke, indem er die Modelle in die Lage versetzt, auf Echtzeitinformationen oder domänenspezifisches Wissen zuzugreifen, um genauere und umfassendere Antworten zu erzeugen.
   • Beispiel für einen Anwendungsfall.
     • Abfrage von Informationen in Echtzeit. Sie können zum Beispiel aktuelle Wetterdaten, Nachrichten, Aktienkurse usw. abrufen.
     • Suche in der Wissensdatenbank. Zum Beispiel die Abfrage der internen Wissensdatenbank des Unternehmens, der Produktdokumentation, der FAQs usw., um den Benutzern professionellere Antworten zu geben.
     • API-Datenintegration. Holen Sie sich beispielsweise Produktinformationen, Flugdynamik, geografische Standortinformationen usw. von externen APIs, um den Dialoginhalt anzureichern.
   • Umsetzung. Entwicklerdefinierte Funktionen zum Abrufen von Daten (z. B. get_weather, search_knowledge_base), und in Werkzeuge die dem Modell in den Parametern zur Verfügung gestellt werden. Wenn das Modell feststellt, dass externe Informationen erforderlich sind, ruft es diese Funktionen auf und erhält die Ergebnisse, die dann in die endgültige Antwort integriert werden.
2. Taking Action - modellgesteuerte Automatisierung.
   • Über die Bereitstellung von Informationen hinaus: Praktiken zum Anfassen. Der Funktionsaufruf beschränkt sich nicht nur auf das Abrufen von Informationen, sondern geht noch weiter, indem er es dem Modell ermöglicht, externe Systeme zur Durchführung tatsächlicher Vorgänge anzusteuern, was eine tiefere Automatisierung und Anwendungsszenarien ermöglicht.
   • Verbesserung des Nutzens und der Anwendung von Modellen. So können Modelle nicht nur Gesprächspartner sein, sondern auch intelligente Assistenten, die dem Nutzer bei einer Vielzahl von Aufgaben helfen.
   • Beispiel für einen Anwendungsfall.
     • Automatisierte Arbeitsabläufe. Zum Beispiel das Absenden von Formularen, das Erstellen von Kalenderereignissen, das Versenden von E-Mails, das Buchen von Flügen und Hotels und so weiter.
     • Kontrolle der Anwendung. Beispiele sind die Änderung des Status einer Anwendung (UI/Front-End oder Back-End), die Steuerung von Smart-Home-Geräten und vieles mehr.
     • Agentischer Arbeitsablauf. Je nach Inhalt des Gesprächs kann es beispielsweise an ein spezielleres Kundenservicesystem weitergeleitet werden oder komplexere automatisierte Prozesse auslösen.
   • Umsetzung. Vom Entwickler definierte Funktionen zur Durchführung bestimmter Operationen (z. B. senden_email, create_calendar_event), und in Werkzeuge die dem Modell in den Parametern zur Verfügung gestellt werden. Das Modell kann diese Funktionen auf der Grundlage der Benutzerabsicht aufrufen und die entsprechenden Parameter übergeben, um eine Aktion auszulösen.

Weitere wichtige Merkmale des Funktionsaufrufs V2 (Unterstützung von Datenerfassungs- und Ausführungsaktionen).

• Werkzeuge Parameter und Funktionsschema. Bietet eine strukturierte Methode zur Definition und Verwaltung der Funktionen, die ein Modell aufrufen kann, einschließlich Funktionsnamen, Beschreibungen und Parameterdefinitionen, um sicherzustellen, dass das Modell die Funktionen genau versteht und aufruft.
• Strenger Modus. Verbesserung der Zuverlässigkeit und Genauigkeit von Funktionsaufrufen, um sicherzustellen, dass das Modell Funktionsaufrufe ausgibt, die genau den vordefinierten Mustern entsprechen.
• Werkzeugauswahl und Steuerung paralleler Funktionsaufrufe. Bietet eine feinere Steuerung, die es Entwicklern ermöglicht, das Verhalten von modellaufgerufenen Funktionen auf Anwendungsszenarien zuzuschneiden, z. B. das Erzwingen von Aufrufen bestimmter Funktionen oder die Begrenzung der Anzahl paralleler Aufrufe.
• Streaming. Verbessern Sie die Benutzerfreundlichkeit, indem Sie den Ausfüllprozess der Funktionsparameter in Echtzeit anzeigen, so dass die Benutzer den Denkprozess des Modells intuitiver verstehen können.

Zusammenfassung.

Der Kernwert von Function calling V2 besteht darin, dass durch Datenerfassung (RAG-Implementierung) im Gesang antworten eine Aktion ausführen Diese beiden Funktionen erweitern die Anwendungsgrenzen von Big Language-Modellen erheblich. Das Modell kann nicht nur auf externe Informationen zugreifen und diese nutzen, um intelligentere und praktischere Antworten zu generieren, sondern auch externe Systeme dazu bringen, Operationen auszuführen und einen höheren Automatisierungsgrad zu erreichen, was die Grundlage für den Aufbau leistungsfähigerer KI-Anwendungen bildet. Die Datenerfassung als Implementierung von RAG ist eine Schlüsselfunktion von Function calling V2 in wissensintensiven Anwendungen.

Hier ist die offizielle OpenAI Funktionsaufruf(Funktionsaufruf) Eine neue Version der Beschreibung, die es dem Modell ermöglicht, Daten abzurufen und Operationen durchzuführen.

Funktionsaufruf bietet eine leistungsstarke und flexible Möglichkeit für OpenAI-Modelle, mit Ihrem Code oder externen Services zu interagieren, und hat zwei Hauptanwendungsfälle:

Wenn Sie nurModellerzeugung JSONBitte beachten Sie die OpenAI-Dokumentation zu strukturierten Ausgaben, um sicherzustellen, dass das Modell immer Ausgaben erzeugt, die mit den von Ihnen bereitgestellten Ausgaben übereinstimmen. JSON-Schema Die Antwort.

Wetter abrufen

Beispiel für einen Funktionsaufruf mit der Funktion get_weather

von openai import OpenAI
client = OpenAI()
tools = [{
"typ": "funktion", "funktion": {
"function": {
"name": "get_weather", "description": "Ermittelt die aktuelle Temperatur für einen bestimmten Ort.
"description": "Ermittelt die aktuelle Temperatur an einem bestimmten Ort." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "Stadt und Land
"description": "Stadt und Land, z.B. Bogotá, Kolumbien"
}
}, "required": [ [ "Stadt und Land, z. B. Bogotá, Kolumbien" }
"erforderlich": [
"Standort"
], "additionalProperties": False
"additionalProperties": False
}, "strict": Wahr
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Wie ist das Wetter in Paris heute?"}] ,
tools=tools
)
print(completion.choices[0].message.tool_calls)

Ausfuhren

[{
"id": "call_12345xyz",
"type": "function",
"function": {
"name": "get_weather", "arguments":"{\"location":\Paris, Frankreich\" }
"arguments":"{\"location\":\"Paris, France\"}"
}
}]

E-Mail

Beispiel für einen Funktionsaufruf mit der Funktion send_email

von openai import OpenAI
client = OpenAI()
tools = [{
"typ": "funktion", "funktion": {
"function": {
"name": "send_email", "description": "Sendet eine E-Mail an den angegebenen Betreff.
"description": "Sendet eine E-Mail mit Betreff und Nachricht an den angegebenen Empfänger." ,
"parameter": {
"type": "object", "properties": {
"properties": {
"to": {
"type": "string", "description": { "E-Mail-Adresse des Empfängers.
"description": "E-Mail-Adresse des Empfängers".
},
"subject": {
"type": "string",
"description": "Betreffzeile der E-Mail."
},
"body": {
"Typ": "Zeichenfolge",
"description": "Text der E-Mail-Nachricht".
}
},
"required": [
"to".
"Betreff".
"body"
], "additionalProperties": False
"additionalProperties": False
}, "additionalProperties": False
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Kannst du eine E-Mail an ilan@example.com und katia@example.com schicken und "Hallo" sagen?"}] ,
tools=tools
)
print(completion.choices[0].message.tool_calls)

Ausfuhren

[
{
"id": "call_9876abc",
"type": "function",
"function": {
"name": "send_email", "arguments":"{\"to\":\",\"\","\","\".
"arguments":"{\"to\":\"ilan@example.com\",\"subject\":\"Hello!\",\"body\":\"Just wanted to say hi\" }"
}
}, {
{
"id": "call_9876abc", "type".

"function": {
"name": "send_email", "arguments":"{\to_":\",\\font/colour
"arguments":"{\"to\":\"katia@example.com\",\"subject\":\"Hello!\",\"body\":\"Just wanted to say hi\" }"
}
}
]

Suche in der Wissensdatenbank

Beispiel für einen Funktionsaufruf mit der Funktion search_knowledge_base

von openai import OpenAI
client = OpenAI()
tools = [{
"typ": "funktion", "funktion": {
"function": {
"name": "search_knowledge_base", "description": "Durchsucht eine Wissensdatenbank nach Informationen über ein Thema.
"description": "Fragt eine Wissensdatenbank ab, um relevante Informationen zu einem Thema zu finden." ,
"parameter": {
"type": "object", "properties": {
"properties": {
"query": {
"type": "string", "description": { "Benutzerfrage oder Suchanfrage.
"description": "Benutzerfrage oder Suchabfrage".
},
"Optionen": {
"Typ": "Objekt", "Eigenschaften": {
"properties": {
"num_results": {
"type": "number", "description": "Um an den Anfang der Liste der Ergebnisse zurückzukehren.
"description": "Die Anzahl der am höchsten eingestuften Ergebnisse, die zurückgegeben werden sollen."
},
"domain_filter": {
"type": [
"string".
"null"
],, "description".
"description": "Optionale Domäne zur Eingrenzung der Suche (z. B. "Finanzen", "Medizin"). Wenn nicht erforderlich, geben Sie null an."
},
"sort_by": {
"type": [
"string".
"null"
],, "enum": [ "enum": [ "string", "null
"enum": [
"relevance".
"Datum".
"Beliebtheit".
"alphabetisch"
],, "description": "Wie die Ergebnisse sortiert werden.
"description": "Wie die Ergebnisse sortiert werden sollen. Übergeben Sie null, wenn nicht erforderlich."
}
},
"erforderlich": [
"num_results".
"domain_filter",
"sort_by"
], "additionalProperties": False
"additionalProperties": Falsch
}
}, "additionalProperties": False }
"required": [
"query", "options": False } }, "required": [
"options"
], "additionalProperties": False
"additionalProperties": False
}, "strict": Wahr
"strict": True
}
}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Hier finden Sie Informationen über den ChatGPT von Informationen?"}] ,
tools=tools
)
print(completion.choices[0].message.tool_calls)

Ausfuhren

[{
"id": "call_4567xyz",
"type": "function",
"function": {
"name": "search_knowledge_base", "arguments":"{\query": "Was ist ChatGPT
"arguments":"{\"query\":\"What is ChatGPT?\",\"options\":{\"num_results\":3,\"domain_filter\":null,\"sort_by\":\"relevance\"}}}"
}
}]

skizziert.

Sie können das OpenAI-Modell zugänglich machen, indem Sie ihm den Zugriff auf die Werkzeuge um seine Funktionalität zu erweitern.Werkzeuge Sie kann zwei Formen annehmen:

In diesem Leitfaden wird erläutert, wie Sie das Beste aus dem Funktionsaufruf Geben Sie dem Modell Zugriff auf Ihre eigenen Funktionen. Auf der Grundlage von Systemaufforderungen und Meldungen kann das Modell entscheiden, diese Funktionen aufzurufen - dieAnstatt (oder zusätzlich zu) Text oder Audio zu erzeugen.

Danach müssen Sie den Funktionscode ausführen, die Ergebnisse zurücksenden, und das Modell wird die Ergebnisse in seine endgültige Antwort integrieren.

Beispielfunktion (Rechnen)

Betrachten wir die Möglichkeit, dass das Modell den folgenden definierten realen Wert verwendet get_weather Schritte der Funktion:

Beispiel einer get_weather-Funktion, die in Ihrer Codebasis implementiert ist

import requests
def get_weather(latitude, longitude): response = requests.
response = requests.get(f "https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}¤t=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m") geschwindigkeit_10m&stündlich=Temperatur_2m,relative_Luftfeuchtigkeit_2m,wind_geschwindigkeit_10m")
data = response.json()
return data['current']['temperature_2m']

Im Gegensatz zum vorherigen Flussdiagramm erfordert diese Funktion eine genaue Breitengrad im Gesang antworten Längengradund nicht generisch Standort Parameter. (Unser Modell kann jedoch die Koordinaten vieler Orte automatisch bestimmen!)

Funktionsaufrufschritt

Verwenden Sie das definierte Funktionsaufrufmodell - zusammen mit Ihren System- und Benutzernachrichten.

Schritt 1: Aufruf des Modells mit dem definierten Werkzeug get_weather

von openai importieren OpenAI
json importieren
client = OpenAI()
tools = [{
"typ": "funktion", "funktion": {
"function": {
"name": "get_weather", "description": "Ermittelt die aktuelle Temperatur an den angegebenen Koordinaten.
"description": "Ermittelt die aktuelle Temperatur in Grad Celsius für die angegebenen Koordinaten." ,
"parameter": {
"type": "object", "properties": {
"properties": {
"latitude": {"type": "number"}, "description": {"parameters": {"type": "object", "properties": {
"longitude": {"type": "number"}
}, "required": ["latitude": ["number"], "longitude": {"type": "number"}
"required": ["latitude", "longitude"], "additionalProperties": F
"additionalProperties": False
}, "strict": Wahr
"strict": True
}
}]
messages = [{"role": "user", "content": "Wie ist das Wetter in Paris heute?"}]
completion = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools.
)

Schritt 2: Das Modell entscheidet, welche Funktion aufgerufen werden soll - das Modell gibt den Namen und die Eingabeparameter zurück.

completion.choices[0].message.tool_calls

[{
"id": "call_12345xyz",
"type": "function",
"function": {
"name": "get_weather", "arguments":"{66,\", "arguments": "48.8566,\
"arguments":"{\"latitude\":48.8566,\"longitude\":2.3522}"
}
}]

Schritt 3: Ausführen des Funktionscodes - Analysieren der Antwort des Modells und Verarbeiten des Funktionsaufrufs

Führen Sie die Funktion get_weather aus

tool_call = completion.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_weather(args["latitude"], args["longitude"])

Schritt 4: Übermittlung der Ergebnisse an das Modell, damit dieses die Ergebnisse in seine endgültige Antwort integrieren kann.

Ergebnisse bereitstellen und das Modell erneut aufrufen

messages.append(completion.choices[0].message) # append model's function call message
messages.append({ # append result message

"tool_call_id": tool_call.id, "content": str(result)
"inhalt": str(ergebnis)
})
completion_2 = client.chat.completions.create(
model="gpt-4o",
messages=Nachrichten,
tools=tools, )
)

Schritt 4: Modellreaktion - Integrieren Sie die Ergebnisse in die Ausgabe.

completion_2.choices[0].message.content

"Die aktuelle Temperatur in Paris beträgt 14°C (57.2°F)."

Definieren von Funktionen

Funktion kann zu jeder API-Anfrage hinzugefügt werden. Werkzeuge Parameter in der Funktion Das Objekt wird in Form eines Objekts eingestellt.

Eine Funktion wird durch ihr Schema definiert, das dem Modell mitteilt, was die Funktion tut und welche Eingabeparameter erwartet werden. Es enthält die folgenden Felder:

Beispiele für Funktionsmuster

{
"Typ": "Funktion", "Funktion": {
"function": {
"name": "get_weather",
"description": "Ruft das aktuelle Wetter für einen bestimmten Ort ab." ,
"parameter": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "Stadt und Land
"description": "Stadt und Land, z.B. Bogotá, Kolumbien"
},
"units": {

"enum": [
"celsius", "fahrenheit
"fahrenheit"
],, "description": "Temp.
"description": "Die Einheit, in der die Temperatur zurückgegeben wird."
}
}, "description": "Die Einheiten, in denen die Temperatur zurückgegeben wird.
"required": [
"location".
"units"
], "additionalProperties": False
"additionalProperties": False
}, "strict": Wahr
"strict": True
}
}

auf Grund von Parameter die durch das JSON-Schema definiert sind, so dass Sie seine zahlreichen Funktionen nutzen können, z. B. Eigenschaftstypen, Aufzählungen, Beschreibungen, verschachtelte Objekte und rekursive Objekte.

(fakultativ) Funktionsaufrufe mit pydantic und zod

Obwohl wir Sie ermutigen, Funktionsmodi direkt zu definieren, bietet unser SDK Hilfsfunktionen, die zur Konvertierung der pydantisch im Gesang antworten zod Objekte werden in Muster umgewandelt. Nicht alle pydantisch im Gesang antworten zod Funktionen werden unterstützt.

Definition von Objekten zur Darstellung von Funktionsmustern

from openai import OpenAI, pydantic_function_tool
from pydantic import BaseModel, Feld
client = OpenAI()
class GetWeather(BaseModel).
location: str = Feld(
... , description="Stadt und Land, z.B. Bogotá.
description="Stadt und Land, z. B. Bogotá, Kolumbien")
)
tools = [pydantic_function_tool(GetWeather)]
completion = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Wie ist das Wetter in Paris heute?"}] ,
tools=tools
)
print(completion.choices[0].message.tool_calls)

Bewährte Praktiken für die Definition von Funktionen

Schreiben Sie klare und detaillierte Funktionsnamen, Parameterbeschreibungen und Anweisungen.

• Beschreiben Sie klar und deutlich, wofür die Funktion und die einzelnen Parameter verwendet werden (und ihr Format) und was die Ausgabe darstellt.
• Verwenden Sie Systemhinweise, um zu beschreiben, wann die einzelnen Funktionen zu verwenden sind (und wann nicht). In der Regel sagen Sie dem Modell genau, was es tun soll.
• Enthält Beispiele und Sonderfälle, insbesondere bei der Behebung von wiederkehrenden Fehlern. (Achtung! Das Hinzufügen von Beispielen kann die Leistung des Inferenzmodells beeinträchtigen).
  Anwendung bewährter Verfahren der Softwaretechnik.
  • Die Funktionen sollten leicht verständlich und intuitiv sein. (Prinzip der geringsten Überraschung)
  • Verwenden Sie Aufzählungen und Objektstrukturen, um ungültige Zustände nicht darstellbar zu machen. (Zum Beispiel.toggle_light(on: bool, off: bool) (Ungültige Anrufe erlaubt)
  • Bestehen Sie den Praktikanten-Test. Kann der Praktikant/Mensch die Funktion nur mit dem, was Sie dem Modell gegeben haben, richtig anwenden? (Wenn nicht, welche Fragen würde man Ihnen stellen? Ergänzen Sie die Antwort in der Aufforderung).

Minimieren Sie den Aufwand für das Modell und verwenden Sie, wo immer möglich, Code.

• Lassen Sie nicht zu, dass das Modell Parameter ausfüllt, die Sie bereits kennen. Wenn Sie zum Beispiel das Menü bereits auf der Grundlage des vorherigen auftrag_idWenn Sie die Option nicht setzen wollen auftrag_id Parameter - anstelle der Einstellung von Parametern submit_refund()und übergab den Code auftrag_id.
• Führen Sie Funktionen zusammen, die immer sequentiell aufgerufen werden. Wenn Sie zum Beispiel immer die Funktionen in abfrage_ort() gefolgt von einem Aufruf an mark_location()verschieben Sie die Tagging-Logik einfach in den Aufruf der Abfragefunktion.Für eine höhere Genauigkeit sollten Sie die Anzahl der Funktionen klein halten.
  • Bewerten Sie Ihre Leistung anhand einer unterschiedlichen Anzahl von Funktionen.
  • Das Ziel ist es, weniger als 20 Funktionen gleichzeitig zu haben, aber das ist nur eine weiche Empfehlung.

Nutzung von OpenAI-Ressourcen.

• existieren Spielplatz Generierung und Iteration von Funktionsmustern in
• Ziehen Sie eine Feinabstimmung in Betracht, um die Genauigkeit von Funktionsaufrufen bei einer großen Anzahl von Funktionen oder schwierigen Aufgaben zu verbessern.

Token-Verwendung

Auf der untersten Ebene werden Funktionen in Systemmeldungen in der Syntax eingefügt, für die das Modell trainiert wurde. Dies bedeutet, dass Funktionen gegen die kontextuellen Beschränkungen des Modells zählen und als Eingaben verwendet werden Token Gebühren. Wenn Sie mit einem Token-Limit konfrontiert sind, empfehlen wir Ihnen, die Anzahl der Funktionen oder die Länge der Beschreibung der Funktionsargumente zu begrenzen.

Wenn Sie viele Funktionen in Ihrer Werkzeugspezifikation definiert haben, können Sie auch die Feinabstimmung verwenden, um die Anzahl der verwendeten Token zu reduzieren.

Behandlung von Funktionsaufrufen

Wenn ein Modell eine Funktion aufruft, müssen Sie diese ausführen und das Ergebnis zurückgeben. Da die Modellantwort null, einen oder mehrere Aufrufe enthalten kann, ist es am besten, davon auszugehen, dass es mehrere Aufrufe gibt.

Die Antwort enthält eine Werkzeug_Aufrufe Arrays, von denen jedes eine id(das später für die Übermittlung der Ergebnisse der Funktion verwendet wird) und eines, das eine Name und JSON-kodiert Argumente (in Form eines Nominalausdrucks) Funktion.

Beispielantwort mit mehreren Funktionsaufrufen

[
{
"id": "call_12345xyz",
"type": "function", "function".
"function": {
"name": "get_weather", "arguments":"{\"location":\"Paris, France\"}
"arguments":"{\"location\":\"Paris, France\"}"
}
}, {"name": "get_weather", "arguments": "{"location":\"Paris, Frankreich\"}" }
{
"id": "call_67890abc", "type": "function", {
"type": "function", "function": {"id": "call_67890abc", "type": "function", "function".
"function": {
"name": "get_weather", "arguments": \"Bogotá", "location": \"Bogotá", "arguments".
"arguments":"{\"location\":\"Bogotá, Colombia\"}"
}
}, }
{
"id": "call_99999def", "type": "function", {
"type": "function", "function": { "call_99999def", { "id": "call_99999def", "type": "function", "function".
"function": {

"arguments":"{\"to\":\"bob@email.com\",\"body\":\"Hi bob\"}"
}
}
]

Ausführen des Funktionsaufrufs und Anhängen des Ergebnisses

for tool_call in completion.choices[0].message.tool_calls:
name = tool_call.function.name
args = json.loads(werkzeug_aufruf.funktion.argumente)
result = call_function(name, args)
messages.append({
"role": "tool", "tool_call_function.function.arguments", result = call_function.arguments
"werkzeug_aufruf_id": werkzeug_aufruf.id, "inhalt": ergebnis
"Inhalt": Ergebnis
})

In dem obigen Beispiel haben wir eine hypothetische call_function, die jeden Anruf weiterleitet. Dies ist eine mögliche Implementierung:

Ausführung von Funktionsaufrufen und Anhängen von Ergebnissen

def call_function(name, args):
if name == "get_weather":
return get_weather(**args)
if name == "send_email":
return send_email(**args)

Formatierung der Ergebnisse

Das Ergebnis muss eine Zeichenkette sein, aber das Format ist Ihnen überlassen (JSON, Fehlercode, einfacher Text usw.). Das Modell interpretiert die Zeichenkette nach Bedarf.

Wenn Ihre Funktion keinen Rückgabewert hat (z. B. senden_email), geben Sie einfach eine Zeichenkette zurück, um Erfolg oder Misserfolg anzuzeigen. (Zum Beispiel "Erfolg")

Integration der Ergebnisse in die Antworten

Hängen Sie die Ergebnisse an Ihre Nachrichten Anschließend können Sie sie an das Modell zurückschicken, um eine endgültige Antwort zu erhalten.

Ergebnisse an das Modell zurücksenden

completion = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools, )
)

abschließende Antwort

"In Paris hat es etwa 15°C, in Bogotá 18°C, und ich habe diese E-Mail bereits an Bob geschickt."

Zusätzliche Konfigurationen

Auswahl der Werkzeuge

Standardmäßig bestimmt das Modell, wann und wie viele Werkzeuge zu verwenden sind. Sie können die Werkzeug_Wahl Parameter erzwingt ein bestimmtes Verhalten.

• Auto: (Standard (Einstellung)) ruft null, eine oder mehrere Funktionen auf. tool_choice: "auto"
• Erforderlich: Aufruf einer oder mehrerer Funktionen. tool_choice: "erforderlich"
• Forced Function: Genaues Aufrufen einer bestimmten Funktion. tool_choice: {"type": "function", "function": {"name": "get_weather"}}

Sie können auch die Werkzeug_Wahl eingestellt auf "keine", um das Verhalten der nicht weitergegebenen Funktion zu simulieren.

paralleler Funktionsaufruf

Das Modell kann mehrere Funktionen in einer einzigen Runde aufrufen. Sie können dies tun, indem Sie die Option parallele_tool_aufrufe eingestellt auf falsch um dies zu verhindern, wodurch sichergestellt wird, dass genau null oder ein Werkzeug aufgerufen wird.

Achtung! Wenn ein Modell in einer Runde mehr als eine Funktion aufruft, werden diese Aufrufe derzeit durch strict modev deaktiviert.

strenges Modell

Oberbefehlshaber (Militär) Streng eingestellt auf wahr stellt sicher, dass Funktionsaufrufe zuverlässig das Funktionsmuster einhalten, anstatt ihr Bestes zu geben. Wir empfehlen, immer den Strict-Modus zu aktivieren.

Im unteren Bereich wird der strenge Modus durch die Verwendung unserer Funktion für strukturierte Ausgaben implementiert, wodurch mehrere Anforderungen eingeführt werden:

• in Bezug auf Parameter für jedes Objekt in deradditionalProperties muss eingestellt werden auf falsch.
• Alle Felder in den Eigenschaften müssen wie folgt beschriftet sein erforderlich.

Sie können dies tun, indem Sie die null handeln als Typ um optionale Felder anzugeben (siehe das folgende Beispiel).

Strikten Modus aktivieren

{
"Typ": "Funktion", "Funktion": {
"function": {
"name": "get_weather",
"description": "Ruft das aktuelle Wetter für einen bestimmten Ort ab." ,
"strict": true, "parameters": {
"parameter": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "Stadt", "description": "Bogotá,
"description": "Stadt und Land, z.B. Bogotá, Kolumbien"
},
"units": {
"type": ["string", "null"], "enum": ["celsius", ["celsius"], "description": "Stadt und Land, z. B. Bogotá, Kolumbien" }, "units": {
"enum": ["celsius", "fahrenheit"], "description": "Die Temperatur wird
"description": "In welchen Einheiten die Temperatur zurückgegeben wird."
}
},
"required": ["location", "units"], "additionalProperties".
"additionalProperties": False
}
}
}

Strict-Modus deaktivieren

{
"Typ": "Funktion", "Funktion": {
"function": {
"name": "get_weather",
"description": "Ruft das aktuelle Wetter für einen bestimmten Ort ab." ,
"parameter": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "Stadt und Land
"description": "Stadt und Land, z.B. Bogotá, Kolumbien"
},
"units": {

"enum": ["celsius", "fahrenheit"], "description": "Temp.
"description": "In welchen Einheiten die Temperatur zurückgegeben wird."
}
},
"required": ["location"], "description": "Die Einheit, in der die Temperatur zurückgegeben wird." }
}
}
}

Für alle auf der Spielwiese erzeugten Muster ist der strenge Modus aktiviert.

Die Aktivierung des strengen Modus wird zwar empfohlen, hat aber einige Einschränkungen:

• Einige Funktionen des JSON-Schemas werden nicht unterstützt. (Siehe Unterstützte Schemata.)
• Muster werden bei der ersten Anfrage zusätzlich verarbeitet (und dann zwischengespeichert). Wenn Ihr Muster von Anfrage zu Anfrage variiert, kann dies zu höheren Latenzzeiten führen.
• Die Muster werden aus Leistungsgründen zwischengespeichert und kommen nicht für eine Null-Datenspeicherung in Frage.

Streaming

Streaming kann verwendet werden, um den Fortschritt zu zeigen, indem Funktionen angezeigt werden, die aufgerufen werden, während das Modell seine Parameter ausfüllt, oder sogar Parameter in Echtzeit angezeigt werden.

Das Streaming eines Funktionsaufrufs ist dem Streaming einer regulären Antwort sehr ähnlich: Sie würden Strom eingestellt auf wahr und erhalten die Daten mit der delta Block von Objekten.

Aufrufe von Streaming-Funktionen

von openai import OpenAI
client = OpenAI()
tools = [{
"typ": "funktion", "funktion": {
"function": {
"name": "get_weather", "description": "Ermittelt die aktuelle Temperatur für einen bestimmten Ort.
"description": "Ermittelt die aktuelle Temperatur an einem bestimmten Ort." ,
"parameters": {
"type": "object", "properties": {
"properties": {
"location": {
"type": "string", "description": "Stadt und Land
"description": "Stadt und Land, z.B. Bogotá, Kolumbien"
}
}, "erforderlich".

"additionalProperties": Falsch
}, "strict": ["location"], "additionalProperties": False
"strict": True
}
}]
stream = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Wie ist das Wetter in Paris heute?"}] ,
tools=tools,
stream=True
)
for chunk in stream.
delta = chunk.choices[0].delta
print(delta.tool_calls)

Ausgabe delta.tool_calls

[{"index": 0, "id": "call_DdmO9pD3xa9XTPNJ32zg2hcA", "function": {"arguments": "", "name": "get_weather"}, "type": "function"}]]
[{"index": 0, "id": null, "function": {"arguments": "{\"", "name": null}, "type": null}]
[{"index": 0, "id": null, "function": {"arguments": "location", "name": null}, "type": null}]]
[{"index": 0, "id": null, "function": {"arguments": "\":\"", "name": null}, "type": null}]]
[{"index": 0, "id": null, "function": {"arguments": "Paris", "name": null}, "type": null}]]
[{"index": 0, "id": null, "function": {"arguments": ",", "name": null}, "type": null}]]
[{"index": 0, "id": null, "function": {"arguments": " France", "name": null}, "type": null}]]
[{"index": 0, "id": null, "function": {"arguments": "\"}", "name": null}, "type": null}]]
null

Anstatt jedoch Blöcke zu einem einzigen zusammenzufassen Inhalt Zeichenkette, sondern fasst stattdessen die Blöcke zu der kodierten Argumente JSON-Objekt.

Wenn das Modell eine oder mehrere Funktionen aufruft, wird jede der delta (in Form eines Nominalausdrucks) Werkzeug_Aufrufe Felder ausgefüllt werden. Jede Werkzeug_Aufruf Enthält die folgenden Felder:

Viele dieser Felder sind nur beim ersten Aufruf eines Werkzeugs verfügbar. delta Eingestellt z.B. id, undfunktion.name im Gesang antworten Typ.

Der folgende Codeschnipsel zeigt, wie die delta Aggregat zur endgültigen Werkzeug_Aufrufe im Objekt.

Akkumulationstool_Aufruf-Delta

final_tool_calls = {}
for chunk in stream.
for tool_call in chunk.choices[0].delta.tool_calls or []:
index = tool_call.index
if index nicht in final_tool_calls.
final_tool_calls[index] = tool_call
final_tool_calls[index].function.arguments += tool_call.function.arguments

Kumulierte final_tool_calls[0]

{
"index": 0, "id".
"id": "call_RzfkBpJgzeR0S242qfvjadNe",
"function": {
"name": "get_weather", "arguments": {
"arguments":"{\"location\":\"Paris, France\"}"
}
}