openai node
v4.73.0
Esta biblioteca fornece acesso conveniente à API REST OpenAI de TypeScript ou JavaScript.
Ele é gerado a partir de nossa especificação OpenAPI com Stainless.
Para aprender como usar a API OpenAI, confira nossa Referência e Documentação da API.
npm install openaideno add jsr:@openai/openai
npx jsr add @openai/openai Esses comandos tornarão o módulo importável do escopo @openai/openai :
Você também pode importar diretamente do JSR sem uma etapa de instalação se estiver usando o tempo de execução Deno JavaScript:
import OpenAI from 'jsr:@openai/openai' ; A API completa desta biblioteca pode ser encontrada no arquivo api.md junto com muitos exemplos de código. O código abaixo mostra como começar a usar a API de conclusão 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 ( ) ; Fornecemos suporte para respostas de streaming usando 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 ( ) ; Se precisar cancelar um stream, você pode break o loop ou chamar stream.controller.abort() .
Esta biblioteca inclui definições TypeScript para todos os parâmetros de solicitação e campos de resposta. Você pode importá-los e usá-los assim:
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 ( ) ;A documentação para cada método, parâmetro de solicitação e campo de resposta está disponível em docstrings e aparecerá ao passar o mouse na maioria dos editores modernos.
Importante
Versões anteriores deste SDK usavam uma classe Configuration . Consulte o guia de migração v3 para v4.
Ao interagir com a API, algumas ações, como iniciar uma execução e adicionar arquivos aos armazenamentos de vetores, são assíncronas e demoram para serem concluídas. O SDK inclui funções auxiliares que pesquisarão o status até atingir um estado terminal e então retornarão o objeto resultante. Se um método API resultar em uma ação que possa se beneficiar da votação, haverá uma versão correspondente do método terminando em 'AndPoll'.
Por exemplo, para criar uma execução e pesquisa até atingir um estado terminal, você pode executar:
const run = await openai . beta . threads . runs . createAndPoll ( thread . id , {
assistant_id : assistantId ,
} ) ;Mais informações sobre o ciclo de vida de uma execução podem ser encontradas na documentação do ciclo de vida da execução
Ao criar e interagir com armazenamentos de vetores, você pode usar os auxiliares de sondagem para monitorar o status das operações. Por conveniência, também fornecemos um auxiliar de upload em massa para permitir que você carregue vários arquivos simultaneamente.
const fileList = [
createReadStream ( '/home/data/example.pdf' ) ,
...
] ;
const batch = await openai . vectorStores . fileBatches . uploadAndPoll ( vectorStore . id , { files : fileList } ) ;O SDK também inclui auxiliares para processar fluxos e manipular os eventos recebidos.
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` ) ;
}
} ) ;
}
}
} ) ;Mais informações sobre auxiliares de streaming podem ser encontradas na documentação dedicada: helpers.md
Esta biblioteca oferece diversas conveniências para streaming de conclusões de bate-papo, por exemplo:
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 ( ) ; O streaming com openai.beta.chat.completions.stream({…}) expõe vários auxiliares para sua conveniência, incluindo manipuladores de eventos e promessas.
Alternativamente, você pode usar openai.chat.completions.create({ stream: true, … }) que retorna apenas um iterável assíncrono dos pedaços no fluxo e, portanto, usa menos memória (ele não cria um objeto final de conclusão de bate-papo para você).
Se precisar cancelar um stream, você pode break um loop for await ou chamar stream.abort() .
Fornecemos o auxiliar de conveniência openai.beta.chat.completions.runTools({…}) para usar chamadas de ferramentas de função com o endpoint /chat/completions que chama automaticamente as funções JavaScript que você fornece e envia seus resultados de volta para /chat/completions endpoint, em loop enquanto o modelo solicitar chamadas de ferramenta.
Se você passar uma função parse , ela analisará automaticamente os arguments para você e retornará quaisquer erros de análise ao modelo para tentar a recuperação automática. Caso contrário, os argumentos serão passados para a função fornecida como uma string.
Se você passar tool_choice: {function: {name: …}} em vez de auto , ele retornará imediatamente após chamar essa função (e apenas fará um loop para recuperar automaticamente erros de análise).
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!" Assim como .stream() , oferecemos uma variedade de ajudantes e eventos.
Observe que runFunctions também estava disponível anteriormente, mas foi descontinuado em favor de runTools .
Leia mais sobre vários exemplos, como integração com zod, next.js e proxy de um stream para o navegador.
Os parâmetros de solicitação que correspondem aos uploads de arquivos podem ser passados de diversas formas:
File (ou um objeto com a mesma estrutura)Response fetch (ou um objeto com a mesma estrutura)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' ,
} ) ; Quando a biblioteca não consegue se conectar à API, ou se a API retornar um código de status de falha (ou seja, resposta 4xx ou 5xx), uma subclasse de APIError será lançada:
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 ( ) ;Os códigos de erro são os seguintes:
| Código de status | Tipo de erro |
|---|---|
| 400 | BadRequestError |
| 401 | AuthenticationError |
| 403 | PermissionDeniedError |
| 404 | NotFoundError |
| 422 | UnprocessableEntityError |
| 429 | RateLimitError |
| >=500 | InternalServerError |
| N / D | APIConnectionError |
Para obter mais informações sobre solicitações de depuração, consulte estes documentos
Todas as respostas de objeto no SDK fornecem uma propriedade _request_id que é adicionada do cabeçalho de resposta x-request-id para que você possa registrar rapidamente solicitações com falha e reportá-las ao 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 utilizar esta biblioteca com Azure OpenAI, utilize a classe AzureOpenAI em vez da classe OpenAI .
Importante
A forma da API do Azure difere ligeiramente da forma da API principal, o que significa que os tipos estáticos para respostas/parâmetros nem sempre estarão corretos.
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 ) ;Certos erros serão repetidos automaticamente 2 vezes por padrão, com uma pequena espera exponencial. Erros de conexão (por exemplo, devido a um problema de conectividade de rede), 408 Request Timeout, 409 Conflict, 429 Rate Limit e >=500 Erros internos serão todos repetidos por padrão.
Você pode usar a opção maxRetries para configurar ou desabilitar isso:
// 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 ,
} ) ; As solicitações expiram após 10 minutos por padrão. Você pode configurar isso com uma opção 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 ,
} ) ; No tempo limite, um APIConnectionTimeoutError é lançado.
Observe que as solicitações que atingirem o tempo limite serão repetidas duas vezes por padrão.
Os métodos de lista na API OpenAI são paginados. Você pode usar a sintaxe for await … of para iterar pelos itens em todas as 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 ;
}Como alternativa, você pode solicitar uma única página por vez:
