OpenAI Echtzeit -API: Ein Leitfaden mit Beispielen

Mit der neu eingeführten OpenAI-Echtzeit-API können wir schnelle, multimodale Erfahrungen mit geringer Latenz in unsere Anwendungen integrieren. Mit dieser API können wir nahtlose Sprach-zu-Sprach-Interaktionen zwischen Benutzern und Großsprachenmodellen (LLMs) erstellen.

Diese API beseitigt die Notwendigkeit mehrerer Modelle, um sprachgesteuerte Erlebnisse zu erzielen, da sie die vollständige Lösung in einer integrierten API bietet. Ziel ist es nicht nur, die Latenz zu verringern, sondern behält auch die emotionalen Nuancen und den natürlichen Fluss von Gesprächen bei.

In diesem Artikel lernen wir, wie Sie mit der OpenAI-Echtzeit-API mithilfe von AI-Assistenten mit Sprachkontrolliert aufbauen. Wir erstellen persistente WebSocket -Verbindungen mit node.js und wie dies innerhalb des Terminals verwendet werden kann, um mit der API zu kommunizieren. Darüber hinaus fördere ich Sie mit der Bereitstellung einer React -App, die die Funktionen dieser API verwendet.

Verwenden Sie die Echtzeit -API mit WebSockets

Im Gegensatz zu anderen Komponenten der OpenAI -API verwendet die Echtzeit -API WebSockets. WebSockets ist ein Kommunikationsprotokoll, das einen bidirektionalen Kommunikationskanal zwischen einem Client und einem Server festlegt. Im Gegensatz zu dem herkömmlichen Anfrage-Response-Modell, das von HTTP verwendet wird, unterstützen Websockets fortlaufende Echtzeit-Interaktionen. Dies macht Websockets besonders für Echtzeitanwendungen wie Voice Chat geeignet.

Dieser Artikel behandelt die Funktionsweise von Websockets und enthält mehrere Beispiele für die Interaktion mit der Echtzeit -API. 

Wir werden Node.js verwenden, daher müssen wir sicherstellen, dass es auf unserem Computer installiert ist. Wenn nicht, können wir Node.js von seiner offiziellen Website herunterladen und installieren.

initialisieren des Skripts

Um mitzumachen, empfehlen wir, einen Ordner mit der oben erstellten .Env -Datei zu erstellen. Führen Sie in diesem Ordner den folgenden Befehl aus, um das Skript zu initialisieren:

npm init -y && touch index.js

Nach Abschluss dieses Befehls sollten diese Dateien im Ordner enthalten sein:

installieren Sie die Abhängigkeiten

Beginnen Sie mit der Installation von zwei Paketen:

• WS: Dies ist das WebSocket -Paket, das Hauptpaket, das für die Interaktion mit der API erforderlich ist.
• dotenv: Ein Dienstprogrammpaket, das die API -Taste aus der .Env -Datei lädt.

installieren Sie diese, indem Sie den Befehl ausführen:

npm install ws dotenv

Verbinden Sie sich mit der Echtzeit -API

Um eine Verbindung mit der Echtzeit -API zu initiieren, erstellen wir ein neues WebSocket -Objekt, das die API -URL und die Header mit den erforderlichen Informationen übergibt, um eine Verbindung dazu herzustellen:

// Import the web socket library
const WebSocket = require("ws");
// Load the .env file into memory so the code has access to the key
const dotenv = require("dotenv");
dotenv.config();
function main() {
  // Connect to the API
  const url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01";
  const ws = new WebSocket(url, {
      headers: {
          "Authorization": "Bearer " + process.env.OPENAI_API_KEY,
          "OpenAI-Beta": "realtime=v1",
      },
  });
}
main();

Einrichten einer Aktion, wenn die Verbindung geöffnet ist

Der obige Code erstellt die Web -Socket -Verbindung zur API, macht aber noch nichts damit.

Websockets ermöglichen es uns, Aktionen einzurichten, die ausgeführt werden sollen, wenn einige Ereignisse auftreten. Wir können das offene Ereignis verwenden, um einen Code anzugeben, den wir ausführen möchten, sobald die Verbindung hergestellt ist.

Die generische Syntax zum Hinzufügen eines Ereignishörers ist Folgendes:

npm init -y && touch index.js

ersetzen & lt; Event & gt; mit einer Zeichenfolge, die den Namen des Ereignisses und & lt; Funktion & gt; mit einer Funktion, die ausgeführt wird, wenn das Ereignis auftritt. 

So können wir Text anzeigen, sobald die Verbindung fertig ist:

npm install ws dotenv

Um diesen Code auszuführen, verwenden wir den Befehl:

// Import the web socket library
const WebSocket = require("ws");
// Load the .env file into memory so the code has access to the key
const dotenv = require("dotenv");
dotenv.config();
function main() {
  // Connect to the API
  const url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01";
  const ws = new WebSocket(url, {
      headers: {
          "Authorization": "Bearer " + process.env.OPENAI_API_KEY,
          "OpenAI-Beta": "realtime=v1",
      },
  });
}
main();

Wenn die API -Taste korrekt eingestellt ist, wird die Nachricht "Verbindung ist geöffnet" im Terminal angezeigt. Das Skript wird weiter ausgeführt, weil die Verbindung noch geöffnet ist, sodass wir es manuell stoppen müssen.

Einrichten einer Aktion, wenn eine Nachricht empfangen wird

Ein weiteres Ereignis, auf das wir bei der Verwendung von WebSockets antworten können, ist das Nachrichtenereignis. Dies wird jedes Mal ausgelöst, wenn eine Nachricht vom Server empfangen wird. Fügen wir eine Funktion hinzu, die jede empfangene Nachricht anzeigt:

ws.on(<event>, <function>);

Ausführen des Skripts jetzt sollte auch die Sitzung angezeigt. Created Ereignis, das die API beim Initialisierungssitz sendet.

Andere WebSocket -Ereignisse

oben haben wir gelernt, wie man Ereignishörer zu den offenen und Nachrichtenereignissen hinzufügt. WebSockets unterstützt zwei zusätzliche Ereignisse, die wir in unseren Beispielen nicht verwenden werden.

Mit dem endgültigen Ereignis kann ein Rückruf hinzugefügt werden, wenn der Sockel geschlossen ist:

// Add inside the main() function of index.js after creating ws
async function handleOpen() {
  console.log("Connection is opened");
}
ws.on("open", handleOpen);

Mit dem Fehlerereignis wird ein Rückruf hinzugefügt, wenn ein Fehler vorliegt:

node index.js

Kommunikation mit der Echtzeit -API

Mit WebSockets müssen wir ereignisorientiert programmieren. Nachrichten werden auf dem Kommunikationskanal hin und her gesendet, und wir können nicht steuern, wann diese Nachrichten übermittelt oder empfangen werden. 

Der Code, der die Kommunikation initiiert, sollte in HandleOpen () hinzugefügt werden. O Ansonsten würde ein Fehler auftreten, da dieser Code möglicherweise ausgeführt werden kann, bevor der Kommunikationskanal des Web -Socket -Kommunikation erstellt wird.

Das Gleiche gilt für die Codehandhabungsnachrichten. Die gesamte Logik sollte in die Funktion Handlemessage () gehen.

In den kommenden Beispielen verwenden wir den folgenden Code als Ausgangspunkt. Die meisten Änderungen beinhalten die Aktualisierung der Handle und der Handlemessage ().

// Add inside the main() function of index.js
 async function handleMessage(messageStr) {
    const message = JSON.parse(messageStr);
    console.log(message);
}
ws.on("message", handleMessage);

Verwenden Sie die Echtzeit -API zum Senden und Empfangen von Text

Kommunikation mit der Echtzeit -API erfolgt mit Ereignissen. In der OpenAI-Echtzeit-Dokumentations-API werden die von ihr unterstützten Ereignisse aufgeführt. Wir verwenden das Ereignis von Conversation.Item.Create, um ein Gespräch zu initiieren. Ereignisse werden als JSON -Objekte dargestellt, deren Felder in der Dokumentation beschrieben sind.

Hier ist ein Beispiel für ein Gespräch.item.create Event Senden der Eingabeaufforderung “Erklären Sie in einem Satz, was ein Web -Socket ist“:

async function handleClose() {
  console.log(“Socket closed”);
}
ws.on(“close”, handleClose);

Dieses Ereignis teilt der API mit, dass wir eine Textgespräch initiieren möchten. Dies wird im Inhaltsfeld angegeben, indem Sie einen Typ "input_text" verwenden und eine Textaufforderung bereitstellen.

Wir verwenden die Ws.Send () -Methode, um eine Nachricht zu senden. Das Web -Socket -Paket erwartet eine Zeichenfolge als Argument, daher müssen wir unser JSON -Ereignis mit der Funktion jSON.Stringify () in eine Zeichenfolge konvertieren. Wenn wir diese zusammenstellen, können wir das obige Ereignis senden:

npm init -y && touch index.js

Dies wird das Gespräch initiieren, aber es wird die API nicht ausgelöst, um uns eine Antwort automatisch zu senden. Um eine Antwort auszulösen, senden wir ein Ereignis. Hier ist ein Beispiel:

npm install ws dotenv

Dieses Ereignis verwendet den Parameter der Modalities -Antwort, um eine Textantwort zu fordern. Die Anweisungen sind der wichtigste Teil und beschreiben, was das Modell in diesem Fall eine generische Eingabeaufforderung erfragt, um den Benutzer zu unterstützen.

Wir senden diese beiden Ereignisse in der Funktion "HandleOpen (), damit ein Gespräch eingeleitet wird, sobald die Verbindung hergestellt wird. Hier ist die vollständige Implementierung der Funktion "HandleOpen () aus diesem Beispiel:

// Import the web socket library
const WebSocket = require("ws");
// Load the .env file into memory so the code has access to the key
const dotenv = require("dotenv");
dotenv.config();
function main() {
  // Connect to the API
  const url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01";
  const ws = new WebSocket(url, {
      headers: {
          "Authorization": "Bearer " + process.env.OPENAI_API_KEY,
          "OpenAI-Beta": "realtime=v1",
      },
  });
}
main();

In Bezug auf die eingehenden Nachrichten gibt es drei Arten von Ereignissen, die für dieses Beispiel erwähnenswert sind: die Antwort.text.delta, response.text.done und response.done Ereignisse:

• Die Antwort.Text.delta -Ereignisse enthalten die Antwort in den Stücken im Delta -Feld. Sie sind wichtig, wenn wir eine Echtzeiterfahrung bieten möchten, da sie es uns ermöglichen, den Reaktionsanteil sofort zu streamen. 
• Die Antwort.Text.done markiert das Ende der Textantwort und enthält die vollständige Antwort im Textfeld.
• Die Antwort.Done markiert das Ende der Antwort.

Wir können angeben, wie unser Skript mithilfe einer Switch -Anweisung in der Funktion Handlemessage () auf diese Ereignisse reagiert:

ws.on(<event>, <function>);

In diesem Beispiel verwenden wir die Antwort.text.delta -Veranstaltung, um die Reaktion auf die Konsole zu drucken, sobald wir sie erhalten. Wenn die Antwort abgeschlossen ist, wird das Ereignis der Antwort.text.Done ausgelöst, und wir drucken eine neue Zeile, um anzuzeigen, dass die Ausgabe abgeschlossen ist. Schließlich schließen wir den Web -Socket, wenn wir das Ereignis erhalten.

Um dieses Beispiel auszuführen, fügen wir diese Funktionen in den obigen Vorlagencode ein und führen sie mit dem Befehl aus:

// Add inside the main() function of index.js after creating ws
async function handleOpen() {
  console.log("Connection is opened");
}
ws.on("open", handleOpen);

Dies erzeugt eine Antwort im Terminal auf die Eingabeaufforderung "Erklären Sie in einem Satz, was ein Web -Socket ist", ähnlich wie bei der Verwendung von ChatGPT. 

Der vollständige Code für das Textbeispiel ist hier verfügbar.

Verwenden Sie die Echtzeit -API zum Senden und Empfangen von Audio

Das vorherige Beispiel zeigte, wie wir mit Textdaten umgehen. Das reale Interesse an der Echtzeit-API besteht jedoch darin, einen Sprachassistenten zu erstellen, der in Echtzeit antwortet.

Die Handhabung von Audiodaten ist etwas komplizierter als der Umgang mit Textdaten. Wir werden einige Details überspringen, die spezifisch für die Funktionsweise von Audio sind, da sie uns vom Hauptthema dieses Artikels ablenken würden.

Erstens installieren wir zwei Pakete:

npm init -y && touch index.js

• knoten-record-lpcm16 zeichnet Sound aus dem Mikrofon auf, damit wir eine Sprachaufforderung senden können.
• Lautsprecher wird verwendet, um die AI -Sprachantwort zu spielen.

Wir müssen auch SOX (Sound Exchange) installieren, ein Befehlszeilen-Dienstprogramm für die Audioverarbeitung, mit dem die Knotenbibliothek mit dem Mikrofon mit dem Mikrofon eingestuft wird und Audio aufzeichnet. Verwenden Sie Brew Install Sox, um es auf MacOS oder sudo APT zu installieren. Installieren Sie SOX unter Linux.

Wenn diese Pakete installiert sind, importieren wir sie und fügen eine Funktion startercording () hinzu, die die Audioaufforderungen des Benutzers aufzeichnet. Wir erklären die Funktion nicht im Detail, da sie uns von unserem Hauptthema zu stark ablenken würde. 

Fügen Sie den folgenden Code zur Datei index.js hinzu, nachdem Sie die Umgebung geladen haben:

npm install ws dotenv

Die Funktion startercording () zeichnet Audio aus dem Mikrofon auf und wartet darauf, dass die Eingabetaste gedrückt wird. 

Als nächstes aktualisieren wir die Funktion main (), indem wir den Lautsprecher () initialisieren, der verwendet wird, um die Antwort der KI zu spielen:

// Import the web socket library
const WebSocket = require("ws");
// Load the .env file into memory so the code has access to the key
const dotenv = require("dotenv");
dotenv.config();
function main() {
  // Connect to the API
  const url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01";
  const ws = new WebSocket(url, {
      headers: {
          "Authorization": "Bearer " + process.env.OPENAI_API_KEY,
          "OpenAI-Beta": "realtime=v1",
      },
  });
}
main();

damit aus dem Weg gehen, können wir die Handlungen () und Handlemessage () implementieren, um Audio zu verarbeiten.

In der Funktion "HandleOpen ()) müssen wir nur die Funktion startercording () aufrufen, um die Audio -Eingabeaufforderung des Benutzers aufzuzeichnen. Wir müssen auch die Ereignisse leicht aktualisieren:

1. Aktualisieren Sie den Inhalt des createConversationEvents, um den Typ "input_audio" anstelle von "input_text zu verwenden, und ersetzen Sie das Textfeld durch Audio: Base64audioData.
2. addio in die Antwortmodalität im CreeperePonseEvent.

Hier ist die aktualisierte Funktion von handleOpen ():

ws.on(<event>, <function>);

Um die Funktion Handlemessage () zu implementieren, ändern wir das Ereignis "response.audio.delta", um den Audio -Puffer zu aktualisieren und das neue Sounddelta zu spielen:

// Add inside the main() function of index.js after creating ws
async function handleOpen() {
  console.log("Connection is opened");
}
ws.on("open", handleOpen);

Wir entfernen das Ereignis "response.text.done" aus der Switch -Anweisung und aktualisieren das Ereignis "response.done", um den Lautsprecher zu stoppen:

node index.js

Die endgültige Implementierung der Funktion Handlemessage () sieht folgt aus:

// Add inside the main() function of index.js
 async function handleMessage(messageStr) {
    const message = JSON.parse(messageStr);
    console.log(message);
}
ws.on("message", handleMessage);

Um dieses Beispiel auszuführen, wenden Sie diese Änderungen auf den Vorlagencode an und führen Sie ihn mit dem Befehl aus:

async function handleClose() {
  console.log(“Socket closed”);
}
ws.on(“close”, handleClose);

Das Mikrofon beginnt mit der Aufnahme. Wir können unsere Anfrage sagen und "Eingeben" drücken, um sie zu senden. Dann wird die Antwort der KI auf den Lautsprechern spielen (stellen Sie sicher, dass das Mikrofon nicht gedämpft ist und die Lautsprecher Volumen haben).

Der vollständige Code für das Audio -Beispiel ist hier verfügbar.

Funktionsaufruf

Eine schöne Funktion der OpenAI -API ist die Fähigkeit, Funktionsaufrufe auszuführen. Wir können dem Assistenten Funktionen hinzufügen, und wenn festgestellt wird, dass eine dieser Funktionen nützlich sein kann, um die Antwort anzugeben, wird ein Ereignis gesendet, in dem eine bestimmte Funktion aufgerufen werden soll.

Die OpenAI -Dokumentation enthält das folgende Diagramm, in dem der Lebenszyklus eines Funktionsaufrufs erklärt wird:

Quelle: OpenAI

Aus dem Diagramm sehen wir, dass der Kunde die Definitionen der Funktionen angeben muss, die der LLM aufrufen kann. Außerdem erfolgt die Funktionsausführung auf der Clientseite. Die KI sendet ein Ereignis, in dem die zu bezeichnete Funktion und ihre Argumente angefordert werden. Dann sind wir dafür verantwortlich, das Ergebnis zurückzuschicken.

befähigen wir unseren Assistenten mit einer Funktion, die zwei Zahlen zusammenfügt. Wir erstellen dieses Beispiel, indem wir das obige Audio -Beispiel erweitern.

Um die verfügbaren Funktionen anzugeben, müssen wir dem LLM eine Liste von Tools zur Verfügung stellen. Jedes Tool ist ein JSON -Objekt, das die Informationen zur Funktion angibt. So können wir ein Tool für die Summenfunktion definieren:

npm init -y && touch index.js

Erklären wir die Objektstruktur:

• Der Typ gibt an, dass wir eine Funktion definieren.
• Der Name wird verwendet, um die Funktion zu identifizieren. Dies ist, was die LLM verwendet, um uns mitzuteilen, welche Funktion sie aufrufen möchte.
• Die Beschreibung wird verwendet, um zu identifizieren, wann das LLM diese Funktion verwenden soll.
• Die Parameter werden verwendet, um die Argumente der Funktion anzugeben. In diesem Fall zwei Zahlen mit dem Namen A und b.

Der nächste Schritt besteht darin, die Funktion in unserem Code zu definieren. Wir werden ein Wörterbuch mit dem Schlüssel Calculate_Sum verwenden, um die angemessene Funktion zu erleichtern, wenn wir auf ein Funktionsaufrufereignis antworten:

npm install ws dotenv

Die API liefert die Funktionsargumente als Wörterbuch mit derselben Struktur, die auf den obigen Parametern definiert ist. In diesem Fall wäre das Wörterbuch {„a“: 3, „B“: 5}.

Die Konstanten von Sumtool und Funktionen können nach den Importen und vor der Funktion main () an die Spitze von index.js hinzugefügt werden.

Als nächstes aktualisieren wir das Ereignis, um die LLM mitzuteilen, dass die Sumtools verfügbar sind. Dies erfolgt durch Hinzufügen der Tools und Tool_Choice Felder zur Antwort:

// Import the web socket library
const WebSocket = require("ws");
// Load the .env file into memory so the code has access to the key
const dotenv = require("dotenv");
dotenv.config();
function main() {
  // Connect to the API
  const url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01";
  const ws = new WebSocket(url, {
      headers: {
          "Authorization": "Bearer " + process.env.OPENAI_API_KEY,
          "OpenAI-Beta": "realtime=v1",
      },
  });
}
main();

Wenn die LLM entscheidet, dass sie eine Funktion aufrufen möchte, wird eine Antwort ausgegeben. Wir müssen darauf reagieren von:

1. Erhalten Sie die Funktionsinformationen und das Aufrufen der Funktion.
2. Senden Sie das Ergebnis des Funktionsaufrufs.
3. eine Antwort anfordern.

Wir verarbeiten dies, indem wir den folgenden Fall zur Switch -Anweisung in der Funktion hanldemessage () hinzufügen:

ws.on(<event>, <function>);

Wenn wir jetzt das Skript ausführen und das Ergebnis des Hinzufügens von zwei Zahlen anfordern, sollte das Modell die Funktion aufrufen und das Ergebnis angeben.

Diese Funktion ist relativ einfach, aber da die Funktion vom Client ausgeführt wird, könnte sie alles sein. Im nächsten Abschnitt werden zwei Beispiele für komplexere Funktionen angezeigt.

Der vollständige Code dieses Beispiels ist hier verfügbar.

MLOPS-Fähigkeiten heute bauen

Beginnen Sie von vorne und gewinnen

Das OpenAI -Team bietet eine Demo -React -App, um die Echtzeit -API zu präsentieren. Hier lernen wir, wie Sie es einrichten und untersuchen, wie es funktioniert. Dies ist ein großartiger Ausgangspunkt, um eine komplexere App zu erstellen.

App Setup

React -Wissen ist nicht erforderlich, um es zum Laufen zu bringen. Sie müssen jedoch mit React vertraut sein, um es zu ändern oder zu erweitern.

ihre App wird in diesem Repository gehostet. Um es einzurichten, beginnen Sie zunächst mit dem folgenden Git -Befehl:

Alternativ können wir es auch manuell von der Github -Schnittstelle herunterladen.

npm init -y && touch index.js

Um die App zu installieren, verwenden wir den folgenden Befehl npm (Knotenpaket verwalten):

Sobald die Installation abgeschlossen ist, erstellen Sie eine Datei namens .Env im Stammordner des Projekts und fügen Sie den folgenden Inhalt ein:

npm install ws dotenv

ersetzen & lt; openai_api_key & gt; mit dem OpenAI -API -Schlüssel.

// Import the web socket library
const WebSocket = require("ws");
// Load the .env file into memory so the code has access to the key
const dotenv = require("dotenv");
dotenv.config();
function main() {
  // Connect to the API
  const url = "wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01";
  const ws = new WebSocket(url, {
      headers: {
          "Authorization": "Bearer " + process.env.OPENAI_API_KEY,
          "OpenAI-Beta": "realtime=v1",
      },
  });
}
main();

Die Anwendung sollte jetzt bereit sein, ausgeführt zu werden. Es besteht aus zwei Teilen:

Ein React -Frontend, der aus der Webbenutzerschnittstelle der Anwendung besteht.

1. Ein Relaisserver wird als Vermittler zwischen dem Frontend und der OpenAI -API verwendet. 

Der Hauptzweck bei der Implementierung eines Relay -Servers zwischen Frontend und OpenAI -API besteht darin, die API -Taste sicher zu speichern. Die Interaktion mit der API ist ohne diesen Schlüssel unmöglich.

Wenn der Schlüssel jedoch an der Frontend gespeichert wäre, wäre er für jeden Benutzer zugänglich. Daher beinhaltet die Lösung die Einrichtung eines Servers, der den Schlüssel sicher speichert und den Datenaustausch zwischen der API und dem Frontend erleichtert. In diesem speziellen Szenario sind Sicherheitsbedenken minimal, da die Anwendung nur lokal ausgeführt wird. 

Um die Anwendung zu starten, ist es erforderlich, sowohl den Relay -Server als auch den Frontend zu initiieren. Verwenden Sie den folgenden Befehl, um den Relay -Server zu starten:

Um den React Frontend zu starten, verwenden Sie den Befehl:

ws.on(<event>, <function>);

Nach dem Laden des Ladens wird im Browser eine Registerkarte geöffnet, wobei die Anwendung darauf ausgeführt wird.

// Add inside the main() function of index.js after creating ws
async function handleOpen() {
  console.log("Connection is opened");
}
ws.on("open", handleOpen);

Verwenden Sie die App

Bevor Sie mit der Verwendung der App beginnen, stellen Sie sicher, dass sich der Computer nicht auf Stummschaltung befindet, und ermöglichen Sie Mikrofonzugriff auf die Anwendung.

wir starten zunächst auf die Schaltfläche "Verbinden". Dies sendet eine "Hallo" Nachricht an die Echtzeit -API, und wir erhalten eine Begrüßung.

Sobald die Verbindung hergestellt ist, wird in der Mitte eine neue Schaltfläche angezeigt, sodass wir mit dem AI -Assistenten sprechen können. 

Um es zu verwenden, drücken und sprechen Sie, ohne die Taste zu veröffentlichen. Die Nachricht wird gesendet, wenn die Schaltfläche veröffentlicht wird.

Die Anwendung verfügt auch über einen VAD -Modus (Sprachaktivitätserkennung), in dem wir keine Taste drücken müssen. In diesem Modus hört die Anwendung kontinuierlich zu, sodass wir uns aktiv mit dem Assistenten unterhalten können. Um es zu verwenden, drücken Sie einfach die Schaltfläche „VAD“ und sprechen Sie.

Funktionen

Wie wir gelernt haben, bietet die Echtzeit -API eine Funktion, mit der die KI bestimmte Funktionen ausführen kann. Diese Demonstration zeigt zwei Funktionen: eine für die Erforschung der Wettervorhersage an einem bestimmten Ort und eine andere zum Hinzufügen von Speicherelementen, um den Assistenten zu personalisieren. 

Erleben Sie diese Funktionen, indem Sie Fragen stellen wie "Wie ist das Wetter in New York?" Und die Vorlieben wie „Meine Lieblingsfarbe ist blau“. Der Assistent liefert mündliche Antworten auf diese Abfragen, und die Informationen werden auch auf der rechten Seite der Anwendung angezeigt.

Es gab Zeiten, in denen ich einen Wetterbericht beantragte, und die Antwort zeigte, dass in diesem Moment keine Unfähigkeit, darauf zuzugreifen. Die Informationen wurden jedoch konsequent auf der rechten Seite angezeigt. Als Demo -App soll es nicht ein voll funktionsfähiges Produkt sein, sondern dient dazu, die Funktionen der API zu präsentieren.

Verständnis des Clients

Dieser Abschnitt erfordert ein hochrangiges Verständnis von React, um zu folgen, wenn wir einige der Implementierungsdetails der Anwendung abdecken.

Wir werden uns die Datei conolepage.tsx ansehen. Hier wird der größte Teil der Anwendungslogik definiert. Die Demo -App verwendet nicht die RAW -Websockets wie in unseren Befehlszeilen -App -Beispiele für node.js. Sie bauten einen Echtzeit-Kunden, der hilft, mit der API zu interagieren. Dies wird oben in der Datei importiert:

npm init -y && touch index.js

Die Integration in die API ist in diesem Aufruf von useeffect () definiert. Der Code in diesem UseEffect () wird ausgeführt, wenn die Konsolenseite ursprünglich gerendert wird. Ähnlich wie bei unserem Skript von Node.js wird beschrieben, wie auf API -Ereignisse reagiert werden. Die primäre Unterscheidung ist die Verwendung des Client -Wrappers von RealimeClient.

Definieren der Tools

Die Funktion von RealTimeClient.addtool () wird verwendet, um Tools zu definieren. Es dauert zwei Parameter:

• Die Tool -Definition JSON -Objekt.
• Die zu ausgeführte Funktion.

Dieser Ansatz vereinfacht die Integration von Tools, da der Client bereits für die Verarbeitung von Ereignissen und die Automatisierung von Funktionsaufrufe ausgestattet ist. Das Speicherwerkzeug ist hier definiert, während die Definition des Wetterwerkzeugs hier definiert ist.

Um zum Beispiel das zuvor definierte Summe -Tool hinzuzufügen, können wir Folgendes tun:

npm init -y && touch index.js

Beachten Sie, dass die Anwendung TypeScript verwendet, wodurch die Spezifikation von Typen innerhalb der Funktionsdefinition erforderlich ist.

Ereignisse anhören

Um ein Ereignis anzuhören, wird die Funktion realTimeclient.on () verwendet. Es akzeptiert zwei Parameter:

1. der Name des Ereignisses.
2. Die zurückgeführte Rückruffunktion.

Dieser Ansatz ähnelt der zuvor verwendeten Funktion von WebSocket.on (), außer dass er einen anderen Satz von Ereignissen implementiert. Ihre Github -Seite enthält die Liste der unterstützten Ereignisse.

In diesem speziellen Beispiel werden die folgenden Ereignisse verwendet:

• Das Ereignis von Realtime.Event Hier wird verwendet, um ein Protokoll aller Ereignisse zu führen.
• Der Fehlerereignis hier protokolliert einfach die Fehler für Debugging -Zwecke an der Konsole.
• Die Konversation.Einrupted Ereignis hier wird verwendet, um die Anforderungen zu stornieren, wenn die Konvertierung unterbrochen wird.
• Schließlich wird das Ereignis von Conversation.Updated verwendet, um neue Audio an den Audio -Stream anzuhängen, wenn neue Chicks aus der API eingehen.

Schlussfolgerung

In diesem Tutorial haben wir die OpenAI-Echtzeit-API und die Verwendung von Websockets für die Echtzeitkommunikation untersucht. Wir haben die Einrichtung einer node.js -Umgebung behandelt, um mit der API zu interagieren, Text- und Audio -Nachrichten zu senden und zu empfangen und Funktionen zu implementieren, die eine verbesserte Funktionalität auffordern.

Wir haben auch die OpenAI -Demo -React -App untersucht, um zu demonstrieren, wie eine grundlegende Sprachassistentenanwendung bereitgestellt wird.

Um mehr über die neuesten OpenAI -Entwicklungstools zu erfahren, empfehle ich diese Tutorials:

• OpenAI -Modell Destillation: Eine Anleitung mit Beispielen
• GPT-4O Vision Feinabstimmung: Ein Leitfaden mit Beispielen

Das obige ist der detaillierte Inhalt vonOpenAI Echtzeit -API: Ein Leitfaden mit Beispielen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!