openai node
v4.73.0
Cette bibliothèque offre un accès pratique à l'API OpenAI REST à partir de TypeScript ou JavaScript.
Il est généré à partir de notre spécification OpenAPI avec Stainless.
Pour savoir comment utiliser l'API OpenAI, consultez notre référence et documentation API.
npm install openaideno add jsr:@openai/openai
npx jsr add @openai/openai Ces commandes rendront le module importable depuis le scope @openai/openai :
Vous pouvez également importer directement depuis JSR sans étape d'installation si vous utilisez le runtime JavaScript Deno :
import OpenAI from 'jsr:@openai/openai' ; L'API complète de cette bibliothèque se trouve dans le fichier api.md avec de nombreux exemples de code. Le code ci-dessous montre comment commencer à utiliser l'API de complétion de chat.
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 ( ) ; Nous fournissons une prise en charge des réponses en streaming à l'aide des événements envoyés par le serveur (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 ( ) ; Si vous devez annuler un flux, vous pouvez break la boucle ou appeler stream.controller.abort() .
Cette bibliothèque comprend des définitions TypeScript pour tous les paramètres de requête et champs de réponse. Vous pouvez les importer et les utiliser comme ceci :
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 ( ) ;La documentation pour chaque méthode, paramètre de requête et champ de réponse est disponible dans docstrings et apparaîtra au survol dans la plupart des éditeurs modernes.
Important
Les versions précédentes de ce SDK utilisaient une classe Configuration . Consultez le guide de migration v3 vers v4.
Lors de l'interaction avec l'API, certaines actions telles que le démarrage d'une exécution et l'ajout de fichiers aux magasins de vecteurs sont asynchrones et prennent du temps. Le SDK comprend des fonctions d'assistance qui interrogeront l'état jusqu'à ce qu'il atteigne un état terminal, puis renverront l'objet résultant. Si une méthode API aboutit à une action qui pourrait bénéficier d'une interrogation, il y aura une version correspondante de la méthode se terminant par « AndPoll ».
Par exemple, pour créer un Run et un sondage jusqu'à ce qu'il atteigne un état terminal, vous pouvez exécuter :
const run = await openai . beta . threads . runs . createAndPoll ( thread . id , {
assistant_id : assistantId ,
} ) ;Plus d'informations sur le cycle de vie d'une exécution peuvent être trouvées dans la documentation sur le cycle de vie de l'exécution.
Lors de la création et de l'interaction avec des magasins de vecteurs, vous pouvez utiliser les assistants d'interrogation pour surveiller l'état des opérations. Pour plus de commodité, nous fournissons également un assistant de téléchargement groupé pour vous permettre de télécharger simultanément plusieurs fichiers à la fois.
const fileList = [
createReadStream ( '/home/data/example.pdf' ) ,
...
] ;
const batch = await openai . vectorStores . fileBatches . uploadAndPoll ( vectorStore . id , { files : fileList } ) ;Le SDK comprend également des assistants pour traiter les flux et gérer les événements entrants.
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` ) ;
}
} ) ;
}
}
} ) ;Plus d’informations sur les assistants de streaming peuvent être trouvées dans la documentation dédiée : helpers.md
Cette bibliothèque offre plusieurs commodités pour la diffusion en continu des discussions, par exemple :
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 ( ) ; Le streaming avec openai.beta.chat.completions.stream({…}) expose diverses aides pour votre commodité, y compris des gestionnaires d'événements et des promesses.
Alternativement, vous pouvez utiliser openai.chat.completions.create({ stream: true, … }) qui renvoie uniquement un itérable asynchrone des morceaux du flux et utilise donc moins de mémoire (il ne crée pas d'objet final de complétion de discussion pour toi).
Si vous devez annuler un flux, vous pouvez break une boucle for await ou appeler stream.abort() .
Nous fournissons l'assistant pratique openai.beta.chat.completions.runTools({…}) pour utiliser les appels d'outils de fonction avec le point de terminaison /chat/completions qui appelle automatiquement les fonctions JavaScript que vous fournissez et renvoie leurs résultats au /chat/completions point final, en boucle tant que le modèle demande des appels à l'outil.
Si vous transmettez une fonction parse , elle analysera automatiquement les arguments pour vous et renverra toutes les erreurs d'analyse au modèle pour tenter une récupération automatique. Sinon, les arguments seront transmis à la fonction que vous fournissez sous forme de chaîne.
Si vous transmettez tool_choice: {function: {name: …}} au lieu de auto , il revient immédiatement après avoir appelé cette fonction (et effectue uniquement une boucle pour récupérer automatiquement les erreurs d'analyse).
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!" Comme avec .stream() , nous proposons une variété d'aides et d'événements.
Notez que runFunctions était également disponible auparavant, mais est devenu obsolète au profit de runTools .
En savoir plus sur divers exemples tels que l'intégration avec zod, next.js et la transmission par proxy d'un flux au navigateur.
Les paramètres de requête qui correspondent aux téléchargements de fichiers peuvent être transmis sous de nombreuses formes différentes :
File (ou un objet avec la même structure)Response fetch (ou un objet avec la même structure)fs.ReadStreamtoFile 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' ,
} ) ; Lorsque la bibliothèque ne parvient pas à se connecter à l'API, ou si l'API renvoie un code d'état d'échec (c'est-à-dire une réponse 4xx ou 5xx), une sous-classe d' APIError sera levée :
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 ( ) ;Les codes d'erreur sont les suivants :
| Code d'état | Type d'erreur |
|---|---|
| 400 | BadRequestError |
| 401 | AuthenticationError |
| 403 | PermissionDeniedError |
| 404 | NotFoundError |
| 422 | UnprocessableEntityError |
| 429 | RateLimitError |
| >=500 | InternalServerError |
| N / A | APIConnectionError |
Pour plus d'informations sur les requêtes de débogage, consultez ces documents
Toutes les réponses d'objet dans le SDK fournissent une propriété _request_id qui est ajoutée à partir de l'en-tête de réponse x-request-id afin que vous puissiez rapidement enregistrer les demandes ayant échoué et les signaler à OpenAI.
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 Pour utiliser cette bibliothèque avec Azure OpenAI, utilisez la classe AzureOpenAI au lieu de la classe OpenAI .
Important
La forme de l'API Azure diffère légèrement de la forme de l'API principale, ce qui signifie que les types statiques des réponses/paramètres ne seront pas toujours corrects.
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 ) ;Certaines erreurs seront automatiquement réessayées 2 fois par défaut, avec un court délai exponentiel. Les erreurs de connexion (par exemple, en raison d'un problème de connectivité réseau), 408 Request Timeout, 409 Conflict, 429 Rate Limit et >=500 Internal Errors seront toutes réessayées par défaut.
Vous pouvez utiliser l'option maxRetries pour configurer ou désactiver ceci :
// 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 ,
} ) ; Les requêtes expirent après 10 minutes par défaut. Vous pouvez configurer cela avec une option timeout :
// 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 ,
} ) ; En cas d'expiration, une APIConnectionTimeoutError est levée.
Notez que les demandes de délai d'attente seront réessayées deux fois par défaut.
Les méthodes de liste de l'API OpenAI sont paginées. Vous pouvez utiliser la syntaxe for await … of pour parcourir les éléments de toutes les pages :
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 ;
}Alternativement, vous pouvez demander une seule page à la fois :
