OpenAI hat kürzlich eine spannende Ergänzung zur OpenAI Completions API eingeführt – Operate Calling. Mit dieser Funktion können Entwickler Funktionen in JSON definieren, die das Modell aufrufen kann, wenn zusätzliche externe Vorgänge zur Erfüllung einer Anfrage erforderlich sind.
Diese Fähigkeit schaltet eine Vielzahl von Funktionalitäten frei, darunter:
- Zugriff auf Echtzeitinformationen wie Wettervorhersagen, Finanzdaten und Nachrichten
- Code speichern und ausführen
- Zugriff auf Daten über SQL-Abfragen oder REST-Dienste
- Verwalten von IoT-Geräten
- Ein Benutzer stellt eine Anfrage.
- Der Nachrichtenprozessor (Anwendungscode) wandelt diese Anfrage in eine Nachrichtenaufforderung um. Außerdem wird der Eingabeaufforderung eine Liste unterstützter Funktionen (z. B. „Websuche“ oder „OS-Befehl ausführen“) hinzugefügt.
- Diese Nachrichtenaufforderung wird dann an die Completions-API gesendet. Wenn das KI-Modell feststellt, dass es zusätzliche Informationen benötigt, um die Anfrage zu erfüllen, prüft es die Liste der bereitgestellten unterstützbaren Funktionen. Wenn eine relevante Funktion gefunden wird, wird eine Anforderung zur Ausführung dieser Funktion zusammen mit den erforderlichen Parametern zurückgegeben.
- Beim Empfang dieser Funktionsanforderung verwendet der Nachrichtenprozessor geeignete Handler, um die Funktion auszuführen.
- Die Ergebnisse der Funktionsausführung und der ursprünglichen Anfrage werden dann an die Completions-API zurückgesendet.
- Die Completions-API verwendet diese Informationen dann, um eine Antwort auf die Anfrage des ursprünglichen Benutzers zu formulieren.
- Abschließend wird diese Antwort an den Benutzer zurückgesendet.“
Während einige dieser Funktionen über ChatGPT und Plugins verfügbar sind, liegt der eigentliche Recreation-Changer in der Möglichkeit, eigenständige Apps zu erstellen, die diese leistungsstarken Funktionen nutzen.
funcDef = {
"identify": "file_save",
"description": "save code or textual content right into a file",
"parameters": {
"kind": "object",
"properties": {
"directory_path": {
"kind": "string",
"description": "the placement of the file to be saved",
},
"file_name": {
"kind": "string",
"description": "the identify of the file to be saved",
},
"file_content": {
"kind": "string",
"description": "the content material of the file to be saved",
},
},
"required": ["directory_path", "file_name", "file_content"],
},
}Schauen wir uns ein Beispiel einer Funktionsdefinition zum Speichern von Textual content in einer Datei an:
Die Definition beschreibt die Funktion. Das Modell verwendet diese, wenn Funktionen mit einem bestimmten Informationsbedarf abgeglichen werden.
Die Definition listet und beschreibt die Parameter, die zum Ausführen der Funktion erforderlich sind.
Bei einer Anfrage kann dann eine Reihe von Funktionsdefinitionen an die API übergeben werden, sodass das Modell Textual content und Code im lokalen Dateisystem speichern kann.
Neben der Auswahl von Modellversionen, die Funktionsaufrufe unterstützen, besteht der Hauptunterschied darin, dass der Satz von Funktionsdefinitionen über den Funktionsparameter an die API gesendet wird, wie unten gezeigt:
def get_completionWithFunctions(messages ,capabilities:str, temperature:int=0, mannequin:str="gpt-3.5-turbo-0613", max_retries:int=3, retry_wait:int=1):
logging.information(f'get_completionWithFunctions begin: mannequin {mannequin} capabilities {capabilities} messages {messages}')retries = 0
whereas retries <= max_retries:
attempt:
response = openai.ChatCompletion.create(
mannequin=mannequin,
messages=messages,
capabilities=capabilities,
function_call = "auto",
temperature=temperature,
)
logging.information(f'get_completion finish: {mannequin}')
response_message = response["choices"][0]["message"]
return response_message
besides RateLimitError as e:
if retries == max_retries:
elevate e
retries += 1
print(f"RateLimitError encountered, retrying... (try {retries})")
time.sleep(retry_wait)
Wenn das Modell eine Benutzeranfrage verarbeitet, die zusätzliche Informationen erfordert, verwendet es die bereitgestellte Liste von Funktionen.
Wenn die Benutzeranforderung lautet: „Bitte schreiben Sie Python-Code, um die ersten N Primzahlen zu berechnen und den Code in primes.py zu speichern“, kann das Modell den Code generieren und unter Berücksichtigung der Funktion „file_save“ mit einer Anforderung zum Speichern antworten Datei.
Der Code, der die Methode get_completionWithFunctions() aufruft, prüft dann die Antwort auf eine Funktionsaufrufanforderung:
response_message = get_completionWithFunctions(completion_messages, function_calling_definition)#test if a operate name is requested
if response_message.get("function_call"):
motion = []
function_name = response_message["function_call"]["name"]
function_args_text = response_message["function_call"]["arguments"]
function_args = json.hundreds(function_args_text)
#extract the paramters and nane of the operate reqested
action_dict = dict()
action_dict["action_name"] = function_name
for key, worth in function_args.gadgets():
action_dict[key] = worth
#execute the operate if out there
response = self.handler.process_action_dict(action_dict, account_name)
response_message_text = QuokkaLoki.handler_repsonse_formated_text(response)
completion_messages.append(response_message)
completion_messages.append(
{
"function": "operate",
"identify": function_name,
"content material": response_message_text,
}
)
#present the response from executing the operate to the mannequin together with the earlier mannequin response
response_message = get_completionWithFunctions(completion_messages, function_calling_definition)
Im obigen Beispiel verfügt der skurrile QuokkaLoki() über verschiedene Handler zur Unterstützung verschiedener Anforderungen wie Dateiladen, Dateispeichern, Befehl ausführen, Internet-Scraping und Websuche. Jeder Handler beschreibt die von ihm bereitgestellte Funktion selbst und erweitert so die Flexibilität und den Nutzen Ihrer KI-gestützten Anwendungen.
Im obigen Beispiel fragt der Benutzer den Assistenten zunächst nach den fünf besten ETFs für den Ruhestand. Der Assistent antwortet mit einer Liste der ETFs und liefert jeweils eine kurze Beschreibung. Diese Interaktion demonstriert die Fähigkeit des Assistenten, Informationen aus seiner bereits vorhandenen Wissensdatenbank zu generieren.
Das Gespräch entwickelt sich, wenn der Benutzer nach weiteren Informationen zu einem bestimmten ETF fragt, dem Vanguard Dividend Appreciation ETF (VIG). Der Assistent antwortet, indem er zusätzliche Informationen über VIG abruft und dem Benutzer außerdem eine Liste von Webquellen zur weiteren Erkundung zur Verfügung stellt. Dies stellt die „Websuchfunktion“ des Assistenten dar und zeigt seine Fähigkeit, nützliche, relevante On-line-Ressourcen zu finden und darzustellen.
Abschließend fordert der Benutzer den Assistenten auf, Textual content von einem der bereitgestellten Hyperlinks abzurufen. Der Assistent ruft einen Textauszug aus dem angegebenen MarketWatch-Hyperlink zum VIG-ETF ab und präsentiert ihn. Diese Aktion demonstriert die „Internet-Scraping“-Fähigkeit des Assistenten und demonstriert seine Fähigkeit, Informationen direkt aus Webseiten zu extrahieren.
Insgesamt hebt dieses Beispiel zwei wichtige Funktionen hervor, die durch Funktionsaufrufe ermöglicht werden: Echtzeit-Websuche und Internet-Textual content-Scraping. Diese Funktionen ermöglichen es der KI, nicht nur Antworten auf der Grundlage ihrer Trainingsdaten zu generieren, sondern auch aktuelle Informationen in Echtzeit aus dem Internet abzurufen und darzustellen, was sie zu einem äußerst dynamischen und leistungsstarken Werkzeug für Benutzer macht.
Denken Sie daran, dass Sie mit Funktionsaufrufen die Fähigkeiten Ihrer KI-gestützten Anwendungen über die Trainingsdaten des Modells hinaus erweitern können. Durch Funktionsaufrufe kann Ihr Assistent mit einer Vielzahl externer Systeme und Dienste interagieren und Benutzern dynamische Antworten in Echtzeit liefern.
Um diese Möglichkeiten zu demonstrieren und Entwicklern, die diese leistungsstarke Funktion nutzen möchten, eine praktische Referenz zu bieten, werfen wir einen Blick auf ein innovatives Projekt namens „Lucy“.
„Lucy“ ist ein innovatives Projekt, das darauf abzielt, die Fähigkeiten der Vervollständigungs-API von OpenAI zu experimentieren und zu nutzen. Ziel des Projekts ist es, das Gesprächsverhalten mithilfe dieser Technologie zu steuern und Prozesse zu automatisieren.
- Agenten: Diese verwalten das Verhalten des Projekts und ermöglichen einfache Chats, geführte Gespräche, Automatisierung und Funktionsaufrufe.
- Immediate Builder: Diese Funktion erweitert die Eingabeaufforderungen basierend auf Benutzeranfragen. Es berücksichtigt langfristige Relevanz, aktuelle Traits oder eine Mischung aus beidem, um eine Reihe von Nachrichten zu erstellen, die mit der Vervollständigungs-API verwendet werden können.
- Abschlüsse: Diese Komponente speichert und ruft Abschlüsse und Nachrichten aus Chats basierend auf Agenten- und Benutzerkonten ab. Außerdem werden Systemrollen für einen Agenten basierend auf dem Agentennamen gespeichert.
- Nachrichtenprozessoren: Sie verarbeiten eingehende Nachrichten und unterstützen die Erstellung von Eingabeaufforderungen, Voreinstellungen, geführte Gespräche, Funktionsaufrufe und Automatisierung.
- Handler: Diese werden von Automatisierungs- und Funktionsaufrufen verwendet, um Anfragen des Modells oder der Agenten zu unterstützen. Sie kümmern sich um das Laden von Dateien, das Speichern von Dateien, die Websuche und das Laden von Webseiten.
- Chunker: Hierbei handelt es sich um Instruments zum Teilen von Textual content. Beim Laden einer großen Textdatei von einer Webseite wird die Datei in Blöcken verarbeitet.
- Kontext: Dies ist ein Informationsspeicher, der mit verschiedenen Agenten geteilt werden kann. Es wird dort eingesetzt, wo mehrere Agenten bei der Bearbeitung einer Benutzeranfrage helfen, beispielsweise in einem geführten Gespräch oder einer Automatisierung.
In „Lucy“ arbeiten die oben genannten Funktionen effektiv zusammen, um das Gesprächsverhalten zu verwalten und zu automatisieren. Der Immediate Builder reichert die Benutzeranforderung an, die die Vervollständigung speichert und bei Bedarf abruft. Nachrichtenprozessoren verarbeiten eingehende Nachrichten und Handler erweitern diese Fähigkeiten weiter. Die Chunker verarbeiten große Datenmengen und der Kontext dient als gemeinsamer Speicher für Informationen.
Die in diesem Blogbeitrag geteilten Codebeispiele basieren auf dem „Lucy“-Projekt, und Sie können die vollständige Codebasis über den bereitgestellten GitHub-Hyperlink erkunden. Dadurch erhalten Sie ein praktisches Verständnis dafür, wie Sie die Funktionsaufruffunktion in der Vervollständigungs-API von OpenAI implementieren und verwenden, um leistungsstarke, interaktive und dynamische KI-Anwendungen zu erstellen.
Mehr zum Projekt finden Sie unter: https://github.com/junwin/lucy
