openai node
v4.73.0
Diese Bibliothek bietet bequemen Zugriff auf die OpenAI REST API über TypeScript oder JavaScript.
Es wird aus unserer OpenAPI-Spezifikation mit Stainless generiert.
Um zu erfahren, wie Sie die OpenAI-API verwenden, schauen Sie sich unsere API-Referenz und Dokumentation an.
npm install openaideno add jsr:@openai/openai
npx jsr add @openai/openai Diese Befehle machen das Modul aus dem @openai/openai -Bereich importierbar:
Sie können auch ohne Installationsschritt direkt aus JSR importieren, wenn Sie die Deno-JavaScript-Laufzeitumgebung verwenden:
import OpenAI from 'jsr:@openai/openai' ; Die vollständige API dieser Bibliothek finden Sie zusammen mit vielen Codebeispielen in der Datei api.md. Der folgende Code zeigt, wie Sie mit der Verwendung der Chat-Abschlüsse-API beginnen.
import OpenAI from 'openai' ;
const client = new OpenAI ( {
apiKey : process . env [ 'OPENAI_API_KEY' ] , // This is the default and can be omitted
} ) ;
async function main ( ) {
const chatCompletion = await client . chat . completions . create ( {
messages : [ { role : 'user' , content : 'Say this is a test' } ] ,
model : 'gpt-4o' ,
} ) ;
}
main ( ) ; Wir bieten Unterstützung für das Streamen von Antworten mithilfe von Server Sent Events (SSE).
import OpenAI from 'openai' ;
const client = new OpenAI ( ) ;
async function main ( ) {
const stream = await client . chat . completions . create ( {
model : 'gpt-4o' ,
messages : [ { role : 'user' , content : 'Say this is a test' } ] ,
stream : true ,
} ) ;
for await ( const chunk of stream ) {
process . stdout . write ( chunk . choices [ 0 ] ?. delta ?. content || '' ) ;
}
}
main ( ) ; Wenn Sie einen Stream abbrechen müssen, können Sie die Schleife break oder stream.controller.abort() aufrufen.
Diese Bibliothek enthält TypeScript-Definitionen für alle Anforderungsparameter und Antwortfelder. Sie können sie wie folgt importieren und verwenden:
import OpenAI from 'openai' ;
const client = new OpenAI ( {
apiKey : process . env [ 'OPENAI_API_KEY' ] , // This is the default and can be omitted
} ) ;
async function main ( ) {
const params : OpenAI . Chat . ChatCompletionCreateParams = {
messages : [ { role : 'user' , content : 'Say this is a test' } ] ,
model : 'gpt-4o' ,
} ;
const chatCompletion : OpenAI . Chat . ChatCompletion = await client . chat . completions . create ( params ) ;
}
main ( ) ;Die Dokumentation für jede Methode, jeden Anforderungsparameter und jedes Antwortfeld ist in Dokumentzeichenfolgen verfügbar und wird in den meisten modernen Editoren beim Hover angezeigt.
Wichtig
Frühere Versionen dieses SDK verwendeten eine Configuration . Weitere Informationen finden Sie im Migrationsleitfaden von v3 zu v4.
Bei der Interaktion mit der API sind einige Aktionen wie das Starten eines Laufs und das Hinzufügen von Dateien zu Vektorspeichern asynchron und nehmen Zeit in Anspruch. Das SDK enthält Hilfsfunktionen, die den Status abfragen, bis ein Endstatus erreicht ist, und dann das resultierende Objekt zurückgeben. Wenn eine API-Methode zu einer Aktion führt, die von der Abfrage profitieren könnte, gibt es eine entsprechende Version der Methode, die auf „AndPoll“ endet.
Um beispielsweise einen Lauf zu erstellen und abzufragen, bis ein Endzustand erreicht ist, können Sie Folgendes ausführen:
const run = await openai . beta . threads . runs . createAndPoll ( thread . id , {
assistant_id : assistantId ,
} ) ;Weitere Informationen zum Lebenszyklus eines Laufs finden Sie in der Run Lifecycle-Dokumentation
Beim Erstellen und Interagieren mit Vektorspeichern können Sie die Polling-Helfer verwenden, um den Status von Vorgängen zu überwachen. Der Einfachheit halber bieten wir auch einen Bulk-Upload-Assistenten an, mit dem Sie mehrere Dateien gleichzeitig hochladen können.
const fileList = [
createReadStream ( '/home/data/example.pdf' ) ,
...
] ;
const batch = await openai . vectorStores . fileBatches . uploadAndPoll ( vectorStore . id , { files : fileList } ) ;Das SDK enthält außerdem Helfer zum Verarbeiten von Streams und zum Behandeln eingehender Ereignisse.
const run = openai . beta . threads . runs
. stream ( thread . id , {
assistant_id : assistant . id ,
} )
. on ( 'textCreated' , ( text ) => process . stdout . write ( 'nassistant > ' ) )
. on ( 'textDelta' , ( textDelta , snapshot ) => process . stdout . write ( textDelta . value ) )
. on ( 'toolCallCreated' , ( toolCall ) => process . stdout . write ( `nassistant > ${ toolCall . type } nn` ) )
. on ( 'toolCallDelta' , ( toolCallDelta , snapshot ) => {
if ( toolCallDelta . type === 'code_interpreter' ) {
if ( toolCallDelta . code_interpreter . input ) {
process . stdout . write ( toolCallDelta . code_interpreter . input ) ;
}
if ( toolCallDelta . code_interpreter . outputs ) {
process . stdout . write ( 'noutput >n' ) ;
toolCallDelta . code_interpreter . outputs . forEach ( ( output ) => {
if ( output . type === 'logs' ) {
process . stdout . write ( `n ${ output . logs } n` ) ;
}
} ) ;
}
}
} ) ;Weitere Informationen zu Streaming-Helfern finden Sie in der entsprechenden Dokumentation: helpers.md
Diese Bibliothek bietet mehrere Annehmlichkeiten für das Streamen von Chat-Abschlüssen, zum Beispiel:
import OpenAI from 'openai' ;
const openai = new OpenAI ( ) ;
async function main ( ) {
const stream = await openai . beta . chat . completions . stream ( {
model : 'gpt-4o' ,
messages : [ { role : 'user' , content : 'Say this is a test' } ] ,
stream : true ,
} ) ;
stream . on ( 'content' , ( delta , snapshot ) => {
process . stdout . write ( delta ) ;
} ) ;
// or, equivalently:
for await ( const chunk of stream ) {
process . stdout . write ( chunk . choices [ 0 ] ?. delta ?. content || '' ) ;
}
const chatCompletion = await stream . finalChatCompletion ( ) ;
console . log ( chatCompletion ) ; // {id: "…", choices: […], …}
}
main ( ) ; Beim Streamen mit openai.beta.chat.completions.stream({…}) stehen Ihnen verschiedene Hilfsprogramme zur Verfügung, darunter Event-Handler und Versprechen.
Alternativ können Sie openai.chat.completions.create({ stream: true, … }) verwenden, das nur eine asynchrone Iterable der Chunks im Stream zurückgibt und somit weniger Speicher verbraucht (es erstellt kein endgültiges Chat-Abschlussobjekt für Du).
Wenn Sie einen Stream abbrechen müssen, können Sie eine for await -Schleife break oder stream.abort() aufrufen.
Wir stellen den praktischen Helfer openai.beta.chat.completions.runTools({…}) für die Verwendung von Funktionstoolaufrufen mit dem Endpunkt /chat/completions bereit, der automatisch die von Ihnen bereitgestellten JavaScript-Funktionen aufruft und ihre Ergebnisse an /chat/completions zurücksendet Endpunkt, Schleife, solange das Modell Toolaufrufe anfordert.
Wenn Sie eine parse -Funktion übergeben, analysiert diese automatisch die arguments für Sie und gibt alle Parsing-Fehler an das Modell zurück, um eine automatische Wiederherstellung zu versuchen. Andernfalls werden die Argumente als String an die von Ihnen bereitgestellte Funktion übergeben.
Wenn Sie tool_choice: {function: {name: …}} anstelle von auto übergeben, kehrt es sofort nach dem Aufruf dieser Funktion zurück (und führt nur eine Schleife aus, um Parsing-Fehler automatisch zu beheben).
import OpenAI from 'openai' ;
const client = new OpenAI ( ) ;
async function main ( ) {
const runner = client . beta . chat . completions
. runTools ( {
model : 'gpt-4o' ,
messages : [ { role : 'user' , content : 'How is the weather this week?' } ] ,
tools : [
{
type : 'function' ,
function : {
function : getCurrentLocation ,
parameters : { type : 'object' , properties : { } } ,
} ,
} ,
{
type : 'function' ,
function : {
function : getWeather ,
parse : JSON . parse , // or use a validation library like zod for typesafe parsing.
parameters : {
type : 'object' ,
properties : {
location : { type : 'string' } ,
} ,
} ,
} ,
} ,
] ,
} )
. on ( 'message' , ( message ) => console . log ( message ) ) ;
const finalContent = await runner . finalContent ( ) ;
console . log ( ) ;
console . log ( 'Final content:' , finalContent ) ;
}
async function getCurrentLocation ( ) {
return 'Boston' ; // Simulate lookup
}
async function getWeather ( args : { location : string } ) {
const { location } = args ;
// … do lookup …
return { temperature , precipitation } ;
}
main ( ) ;
// {role: "user", content: "How's the weather this week?"}
// {role: "assistant", tool_calls: [{type: "function", function: {name: "getCurrentLocation", arguments: "{}"}, id: "123"}
// {role: "tool", name: "getCurrentLocation", content: "Boston", tool_call_id: "123"}
// {role: "assistant", tool_calls: [{type: "function", function: {name: "getWeather", arguments: '{"location": "Boston"}'}, id: "1234"}]}
// {role: "tool", name: "getWeather", content: '{"temperature": "50degF", "preciptation": "high"}', tool_call_id: "1234"}
// {role: "assistant", content: "It's looking cold and rainy - you might want to wear a jacket!"}
//
// Final content: "It's looking cold and rainy - you might want to wear a jacket!" Wie bei .stream() bieten wir eine Vielzahl von Helfern und Ereignissen.
Beachten Sie, dass runFunctions zuvor ebenfalls verfügbar war, jedoch zugunsten von runTools veraltet ist.
Lesen Sie mehr über verschiedene Beispiele, z. B. die Integration mit zod, next.js und die Weiterleitung eines Streams an den Browser.
Anforderungsparameter, die Datei-Uploads entsprechen, können in vielen verschiedenen Formen übergeben werden:
File (oder ein Objekt mit derselben Struktur)fetch Response (oder ein Objekt mit derselben Struktur)fs.ReadStreamtoFile Helfers import fs from 'fs' ;
import fetch from 'node-fetch' ;
import OpenAI , { toFile } from 'openai' ;
const client = new OpenAI ( ) ;
// If you have access to Node `fs` we recommend using `fs.createReadStream()`:
await client . files . create ( { file : fs . createReadStream ( 'input.jsonl' ) , purpose : 'fine-tune' } ) ;
// Or if you have the web `File` API you can pass a `File` instance:
await client . files . create ( { file : new File ( [ 'my bytes' ] , 'input.jsonl' ) , purpose : 'fine-tune' } ) ;
// You can also pass a `fetch` `Response`:
await client . files . create ( { file : await fetch ( 'https://somesite/input.jsonl' ) , purpose : 'fine-tune' } ) ;
// Finally, if none of the above are convenient, you can use our `toFile` helper:
await client . files . create ( {
file : await toFile ( Buffer . from ( 'my bytes' ) , 'input.jsonl' ) ,
purpose : 'fine-tune' ,
} ) ;
await client . files . create ( {
file : await toFile ( new Uint8Array ( [ 0 , 1 , 2 ] ) , 'input.jsonl' ) ,
purpose : 'fine-tune' ,
} ) ; Wenn die Bibliothek keine Verbindung zur API herstellen kann oder die API einen nicht erfolgreichen Statuscode zurückgibt (z. B. 4xx- oder 5xx-Antwort), wird eine Unterklasse von APIError ausgelöst:
async function main ( ) {
const job = await client . fineTuning . jobs
. create ( { model : 'gpt-4o' , training_file : 'file-abc123' } )
. catch ( async ( err ) => {
if ( err instanceof OpenAI . APIError ) {
console . log ( err . status ) ; // 400
console . log ( err . name ) ; // BadRequestError
console . log ( err . headers ) ; // {server: 'nginx', ...}
} else {
throw err ;
}
} ) ;
}
main ( ) ;Die Fehlercodes lauten wie folgt:
| Statuscode | Fehlertyp |
|---|---|
| 400 | BadRequestError |
| 401 | AuthenticationError |
| 403 | PermissionDeniedError |
| 404 | NotFoundError |
| 422 | UnprocessableEntityError |
| 429 | RateLimitError |
| >=500 | InternalServerError |
| N / A | APIConnectionError |
Weitere Informationen zu Debugging-Anfragen finden Sie in diesen Dokumenten
Alle Objektantworten im SDK stellen eine _request_id Eigenschaft bereit, die aus dem x-request-id -Antwortheader hinzugefügt wird, sodass Sie fehlgeschlagene Anforderungen schnell protokollieren und an OpenAI zurückmelden können.
const completion = await client . chat . completions . create ( { messages : [ { role : 'user' , content : 'Say this is a test' } ] , model : 'gpt-4o' } ) ;
console . log ( completion . _request_id ) // req_123 Um diese Bibliothek mit Azure OpenAI zu verwenden, verwenden Sie die AzureOpenAI -Klasse anstelle der OpenAI -Klasse.
Wichtig
Die Azure-API-Form unterscheidet sich geringfügig von der Kern-API-Form, was bedeutet, dass die statischen Typen für Antworten/Parameter nicht immer korrekt sind.
import { AzureOpenAI } from 'openai' ;
import { getBearerTokenProvider , DefaultAzureCredential } from '@azure/identity' ;
const credential = new DefaultAzureCredential ( ) ;
const scope = 'https://cognitiveservices.azure.com/.default' ;
const azureADTokenProvider = getBearerTokenProvider ( credential , scope ) ;
const openai = new AzureOpenAI ( { azureADTokenProvider } ) ;
const result = await openai . chat . completions . create ( {
model : 'gpt-4o' ,
messages : [ { role : 'user' , content : 'Say hello!' } ] ,
} ) ;
console . log ( result . choices [ 0 ] ! . message ?. content ) ;Bestimmte Fehler werden standardmäßig automatisch zweimal wiederholt, mit einem kurzen exponentiellen Backoff. Verbindungsfehler (z. B. aufgrund eines Netzwerkverbindungsproblems), 408 Request Timeout, 409 Conflict, 429 Rate Limit und >=500 Internal Errors werden standardmäßig alle erneut versucht.
Sie können dies mit der Option maxRetries konfigurieren oder deaktivieren:
// Configure the default for all requests:
const client = new OpenAI ( {
maxRetries : 0 , // default is 2
} ) ;
// Or, configure per-request:
await client . chat . completions . create ( { messages : [ { role : 'user' , content : 'How can I get the name of the current day in JavaScript?' } ] , model : 'gpt-4o' } , {
maxRetries : 5 ,
} ) ; Das Timeout für Anfragen erfolgt standardmäßig nach 10 Minuten. Sie können dies mit einer timeout -Option konfigurieren:
// Configure the default for all requests:
const client = new OpenAI ( {
timeout : 20 * 1000 , // 20 seconds (default is 10 minutes)
} ) ;
// Override per-request:
await client . chat . completions . create ( { messages : [ { role : 'user' , content : 'How can I list all files in a directory using Python?' } ] , model : 'gpt-4o' } , {
timeout : 5 * 1000 ,
} ) ; Bei einer Zeitüberschreitung wird ein APIConnectionTimeoutError ausgelöst.
Beachten Sie, dass Anfragen, bei denen eine Zeitüberschreitung auftritt, standardmäßig zweimal wiederholt werden.
Listenmethoden in der OpenAI-API sind paginiert. Sie können die for await … of Syntax verwenden, um Elemente auf allen Seiten zu durchlaufen:
async function fetchAllFineTuningJobs ( params ) {
const allFineTuningJobs = [ ] ;
// Automatically fetches more pages as needed.
for await ( const fineTuningJob of client . fineTuning . jobs . list ( { limit : 20 } ) ) {
allFineTuningJobs . push ( fineTuningJob ) ;
}
return allFineTuningJobs ;
}Alternativ können Sie jeweils nur eine Seite anfordern:
