openai node
v4.73.0
Esta biblioteca proporciona un acceso conveniente a la API REST de OpenAI desde TypeScript o JavaScript.
Se genera a partir de nuestra especificación OpenAPI con Inoxidable.
Para aprender a utilizar la API de OpenAI, consulte nuestra Referencia y documentación de la API.
npm install openaideno add jsr:@openai/openai
npx jsr add @openai/openai Estos comandos harán que el módulo se pueda importar desde el alcance @openai/openai :
También puedes importar directamente desde JSR sin un paso de instalación si estás utilizando el tiempo de ejecución de JavaScript de Deno:
import OpenAI from 'jsr:@openai/openai' ; La API completa de esta biblioteca se puede encontrar en el archivo api.md junto con muchos ejemplos de código. El siguiente código muestra cómo comenzar a utilizar la API de finalización 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 ( ) ; Brindamos soporte para la transmisión de respuestas utilizando 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 ( ) ; Si necesita cancelar una transmisión, puede break del bucle o llamar stream.controller.abort() .
Esta biblioteca incluye definiciones de TypeScript para todos los parámetros de solicitud y campos de respuesta. Puede importarlos y usarlos así:
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 documentación para cada método, parámetro de solicitud y campo de respuesta está disponible en cadenas de documentos y aparecerá al pasar el mouse en la mayoría de los editores modernos.
Importante
Las versiones anteriores de este SDK usaban una clase Configuration . Consulte la guía de migración de v3 a v4.
Al interactuar con la API, algunas acciones, como iniciar una ejecución y agregar archivos a almacenes de vectores, son asincrónicas y tardan en completarse. El SDK incluye funciones auxiliares que sondearán el estado hasta que alcance un estado terminal y luego devolverán el objeto resultante. Si un método API da como resultado una acción que podría beneficiarse del sondeo, habrá una versión correspondiente del método que terminará en 'AndPoll'.
Por ejemplo, para crear una ejecución y sondear hasta que alcance un estado terminal, puede ejecutar:
const run = await openai . beta . threads . runs . createAndPoll ( thread . id , {
assistant_id : assistantId ,
} ) ;Puede encontrar más información sobre el ciclo de vida de una ejecución en la documentación del ciclo de vida de la ejecución.
Al crear e interactuar con almacenes de vectores, puede utilizar los asistentes de sondeo para monitorear el estado de las operaciones. Para mayor comodidad, también proporcionamos un asistente de carga masiva que le permite cargar varios archivos simultáneamente.
const fileList = [
createReadStream ( '/home/data/example.pdf' ) ,
...
] ;
const batch = await openai . vectorStores . fileBatches . uploadAndPoll ( vectorStore . id , { files : fileList } ) ;El SDK también incluye ayudas para procesar transmisiones y manejar los eventos entrantes.
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` ) ;
}
} ) ;
}
}
} ) ;Puede encontrar más información sobre los asistentes de transmisión en la documentación dedicada: helpers.md
Esta biblioteca ofrece varias ventajas para la finalización de chats en streaming, por ejemplo:
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 ( ) ; La transmisión con openai.beta.chat.completions.stream({…}) expone varios asistentes para su conveniencia, incluidos controladores de eventos y promesas.
Alternativamente, puede usar openai.chat.completions.create({ stream: true, … }) que solo devuelve un iterable asíncrono de los fragmentos en la secuencia y, por lo tanto, usa menos memoria (no crea un objeto de finalización de chat final para tú).
Si necesita cancelar una transmisión, puede break de un bucle for await o llamar stream.abort() .
Proporcionamos la cómoda ayuda openai.beta.chat.completions.runTools({…}) para usar llamadas a herramientas de funciones con el punto final /chat/completions que llama automáticamente a las funciones de JavaScript que usted proporciona y envía sus resultados de vuelta a /chat/completions punto final, en bucle siempre que el modelo solicite llamadas a la herramienta.
Si pasa una función parse , analizará automáticamente los arguments por usted y devolverá cualquier error de análisis al modelo para intentar la recuperación automática. De lo contrario, los argumentos se pasarán a la función que proporcione como una cadena.
Si pasa tool_choice: {function: {name: …}} en lugar de auto , regresa inmediatamente después de llamar a esa función (y solo realiza un bucle para recuperar automáticamente los errores de análisis).
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!" Al igual que con .stream() , proporcionamos una variedad de ayudas y eventos.
Tenga en cuenta que runFunctions también estaba disponible anteriormente, pero ha quedado obsoleto en favor de runTools .
Lea más sobre varios ejemplos, como la integración con zod, next.js y la transferencia de una transmisión al navegador.
Los parámetros de solicitud que corresponden a la carga de archivos se pueden pasar de muchas formas diferentes:
File (o un objeto con la misma estructura)Response fetch (o un objeto con la misma estructura)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' ,
} ) ; Cuando la biblioteca no puede conectarse a la API, o si la API devuelve un código de estado de no éxito (es decir, respuesta 4xx o 5xx), se generará una subclase de APIError :
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 ( ) ;Los códigos de error son los siguientes:
| Código de estado | Tipo de error |
|---|---|
| 400 | BadRequestError |
| 401 | AuthenticationError |
| 403 | PermissionDeniedError |
| 404 | NotFoundError |
| 422 | UnprocessableEntityError |
| 429 | RateLimitError |
| >=500 | InternalServerError |
| N / A | APIConnectionError |
Para obtener más información sobre las solicitudes de depuración, consulte estos documentos
Todas las respuestas de objetos en el SDK proporcionan una propiedad _request_id que se agrega desde el encabezado de respuesta x-request-id para que pueda registrar rápidamente las solicitudes fallidas e informarlas a 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 Para usar esta biblioteca con Azure OpenAI, use la clase AzureOpenAI en lugar de la clase OpenAI .
Importante
La forma de la API de Azure difiere ligeramente de la forma de la API principal, lo que significa que los tipos estáticos para respuestas/parámetros no siempre serán correctos.
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 ) ;Ciertos errores se reintentará automáticamente 2 veces de forma predeterminada, con un breve retroceso exponencial. Los errores de conexión (por ejemplo, debido a un problema de conectividad de red), 408 Tiempo de espera de solicitud, 409 Conflicto, 429 Límite de velocidad y >=500 errores internos se volverán a intentar de forma predeterminada.
Puede usar la opción maxRetries para configurar o deshabilitar esto:
// 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 ,
} ) ; Solicita un tiempo de espera después de 10 minutos de forma predeterminada. Puedes configurar esto con una opción de 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 ,
} ) ; Cuando se agota el tiempo de espera, se genera un error APIConnectionTimeoutError .
Tenga en cuenta que las solicitudes cuyo tiempo de espera se agote se reintentará dos veces de forma predeterminada.
Los métodos de lista en la API de OpenAI están paginados. Puede utilizar la sintaxis for await … of para iterar a través de elementos en todas las páginas:
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 ;
}Alternativamente, puede solicitar una sola página a la vez:
