openai node
v4.73.0
ไลบรารีนี้ช่วยให้เข้าถึง OpenAI REST API ได้อย่างสะดวกจาก TypeScript หรือ JavaScript
มันถูกสร้างขึ้นจากข้อกำหนด OpenAPI ของเราด้วย Stainless
หากต้องการเรียนรู้วิธีใช้ OpenAI API โปรดดูข้อมูลอ้างอิงและเอกสารประกอบ API ของเรา
npm install openaideno add jsr:@openai/openai
npx jsr add @openai/openai คำสั่งเหล่านี้จะทำให้โมดูลสามารถนำเข้าได้จากขอบเขต @openai/openai :
คุณยังสามารถนำเข้าได้โดยตรงจาก JSR โดยไม่ต้องมีขั้นตอนการติดตั้ง หากคุณใช้รันไทม์ Deno JavaScript:
import OpenAI from 'jsr:@openai/openai' ; API แบบเต็มของไลบรารีนี้สามารถพบได้ในไฟล์ api.md พร้อมด้วยตัวอย่างโค้ดมากมาย โค้ดด้านล่างแสดงวิธีเริ่มต้นใช้งาน API การเสร็จสิ้นการแชท
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 ( ) ; เราให้การสนับสนุนสำหรับการตอบกลับแบบสตรีมโดยใช้ 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 ( ) ; หากคุณต้องการยกเลิกการสตรีม คุณสามารถ break จากลูปหรือโทรไปที่ stream.controller.abort()
ไลบรารีนี้มีคำจำกัดความของ TypeScript สำหรับพารามิเตอร์คำขอและฟิลด์ตอบกลับทั้งหมด คุณสามารถนำเข้าและใช้งานได้ดังนี้:
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 ( ) ;เอกสารประกอบสำหรับแต่ละวิธี พารามิเตอร์คำขอ และฟิลด์ตอบกลับมีอยู่ในเอกสารและจะปรากฏเมื่อวางเมาส์เหนือในโปรแกรมแก้ไขสมัยใหม่ส่วนใหญ่
สำคัญ
SDK เวอร์ชันก่อนหน้านี้ใช้คลาส Configuration ดูคำแนะนำในการย้ายเวอร์ชัน v3 ถึง v4
เมื่อโต้ตอบกับ API การดำเนินการบางอย่าง เช่น การเริ่มเรียกใช้และการเพิ่มไฟล์ไปยังร้านค้าเวกเตอร์จะไม่ตรงกันและต้องใช้เวลาในการดำเนินการให้เสร็จสิ้น SDK มีฟังก์ชันตัวช่วยซึ่งจะสำรวจสถานะจนกว่าจะถึงสถานะเทอร์มินัลแล้วส่งคืนออบเจ็กต์ผลลัพธ์ หากวิธี API ส่งผลให้เกิดการดำเนินการที่อาจได้รับประโยชน์จากการสำรวจ จะมีเวอร์ชันที่สอดคล้องกันของวิธีการลงท้ายด้วย 'AndPoll'
ตัวอย่างเช่นในการสร้างการเรียกใช้และการสำรวจความคิดเห็นจนกว่าจะถึงสถานะเทอร์มินัลคุณสามารถเรียกใช้ได้:
const run = await openai . beta . threads . runs . createAndPoll ( thread . id , {
assistant_id : assistantId ,
} ) ;ข้อมูลเพิ่มเติมเกี่ยวกับวงจรการใช้งานของการรันสามารถพบได้ในเอกสารประกอบวงจรการใช้งานการรัน
เมื่อสร้างและโต้ตอบกับร้านค้าเวกเตอร์ คุณสามารถใช้ตัวช่วยโพลเพื่อตรวจสอบสถานะของการดำเนินการได้ เพื่อความสะดวก เรายังมีตัวช่วยอัปโหลดจำนวนมากเพื่อให้คุณสามารถอัปโหลดหลายไฟล์พร้อมกันได้
const fileList = [
createReadStream ( '/home/data/example.pdf' ) ,
...
] ;
const batch = await openai . vectorStores . fileBatches . uploadAndPoll ( vectorStore . id , { files : fileList } ) ;SDK ยังมีตัวช่วยในการประมวลผลสตรีมและจัดการเหตุการณ์ที่เข้ามาอีกด้วย
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` ) ;
}
} ) ;
}
}
} ) ;ข้อมูลเพิ่มเติมเกี่ยวกับตัวช่วยสตรีมมิ่งสามารถพบได้ในเอกสารเฉพาะ: helpers.md
ไลบรารีนี้อำนวยความสะดวกหลายประการสำหรับการสตรีมการแชทเสร็จสิ้น เช่น:
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 ( ) ; การสตรีมด้วย openai.beta.chat.completions.stream({…}) จะเปิดเผยตัวช่วยต่างๆ เพื่อความสะดวกของคุณ รวมถึงตัวจัดการเหตุการณ์และคำสัญญา
หรือคุณสามารถใช้ openai.chat.completions.create({ stream: true, … }) ซึ่งจะส่งคืนเฉพาะการวนซ้ำแบบอะซิงก์ของชิ้นส่วนในสตรีมเท่านั้น ดังนั้นจึงใช้หน่วยความจำน้อยลง (ไม่ได้สร้างออบเจ็กต์การแชทขั้นสุดท้ายสำหรับ คุณ).
หากคุณต้องการยกเลิกการสตรีม คุณสามารถ break จาก a for await loop หรือโทร stream.abort()
เราจัดเตรียมตัวช่วยอำนวยความสะดวก openai.beta.chat.completions.runTools({…}) สำหรับการเรียกใช้เครื่องมือฟังก์ชันด้วยจุดสิ้นสุด /chat/completions ซึ่งจะเรียกใช้ฟังก์ชัน JavaScript ที่คุณระบุโดยอัตโนมัติ และส่งผลลัพธ์กลับไปที่ /chat/completions จุดสิ้นสุด วนซ้ำตราบใดที่โมเดลร้องขอการเรียกใช้เครื่องมือ
หากคุณผ่านฟังก์ชัน parse ชั่นจะแยกวิเคราะห์ arguments ให้คุณโดยอัตโนมัติ และส่งกลับข้อผิดพลาดในการแยกวิเคราะห์ไปยังโมเดลเพื่อพยายามกู้คืนอัตโนมัติ มิฉะนั้น args จะถูกส่งไปยังฟังก์ชันที่คุณระบุเป็นสตริง
หากคุณผ่าน tool_choice: {function: {name: …}} แทนที่จะเป็น auto มันจะส่งคืนทันทีหลังจากเรียกใช้ฟังก์ชันนั้น (และจะวนซ้ำเฉพาะข้อผิดพลาดในการแยกวิเคราะห์การกู้คืนอัตโนมัติเท่านั้น)
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!" เช่นเดียวกับ .stream() เรามีตัวช่วยและกิจกรรมต่างๆ มากมาย
โปรดทราบว่าก่อนหน้านี้ runFunctions ก็มีให้ใช้งานได้เช่นกัน แต่เลิกใช้แล้วเพื่อสนับสนุน runTools
อ่านเพิ่มเติมเกี่ยวกับตัวอย่างต่างๆ เช่น การผสานรวมกับ zod, next.js และการส่งกระแสข้อมูลไปยังเบราว์เซอร์
พารามิเตอร์คำขอที่สอดคล้องกับการอัปโหลดไฟล์สามารถส่งผ่านได้หลายรูปแบบ:
File (หรือวัตถุที่มีโครงสร้างเหมือนกัน)Response fetch (หรือวัตถุที่มีโครงสร้างเดียวกัน)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' ,
} ) ; เมื่อไลบรารีไม่สามารถเชื่อมต่อกับ API ได้ หรือหาก API ส่งคืนรหัสสถานะที่ไม่สำเร็จ (เช่น การตอบสนอง 4xx หรือ 5xx) คลาสย่อยของ 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 ( ) ;รหัสข้อผิดพลาดมีดังนี้:
| รหัสสถานะ | ประเภทข้อผิดพลาด |
|---|---|
| 400 | BadRequestError |
| 401 | AuthenticationError |
| 403 | PermissionDeniedError |
| 404 | NotFoundError |
| 422 | UnprocessableEntityError |
| 429 | RateLimitError |
| >=500 | InternalServerError |
| ไม่มี | APIConnectionError |
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับคำขอแก้ไขข้อบกพร่อง โปรดดูเอกสารเหล่านี้
การตอบสนองของออบเจ็กต์ทั้งหมดใน SDK มีคุณสมบัติ _request_id ซึ่งเพิ่มจากส่วนหัวการตอบสนอง x-request-id เพื่อให้คุณสามารถบันทึกคำขอที่ล้มเหลวได้อย่างรวดเร็วและรายงานกลับไปยัง 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 หากต้องการใช้ไลบรารีนี้กับ Azure OpenAI ให้ใช้คลาส AzureOpenAI แทนคลาส OpenAI
สำคัญ
รูปร่าง Azure API แตกต่างจากรูปร่าง API หลักเล็กน้อย ซึ่งหมายความว่าประเภทคงที่สำหรับการตอบกลับ / พารามิเตอร์จะไม่ถูกต้องเสมอไป
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 ) ;ข้อผิดพลาดบางอย่างจะมีการลองใหม่โดยอัตโนมัติ 2 ครั้งตามค่าเริ่มต้น โดยมีการถอยกลับแบบเอ็กซ์โพเนนเชียลสั้นๆ ข้อผิดพลาดในการเชื่อมต่อ (เช่น เนื่องจากปัญหาการเชื่อมต่อเครือข่าย) 408 Request Timeout, 409 Conflict, 429 Rate Limit และ >=500 Internal error ทั้งหมดจะถูกลองใหม่ตามค่าเริ่มต้น
คุณสามารถใช้ตัวเลือก maxRetries เพื่อกำหนดค่าหรือปิดใช้งานสิ่งนี้:
// 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 ,
} ) ; คำขอหมดเวลาหลังจาก 10 นาทีตามค่าเริ่มต้น คุณสามารถกำหนดค่านี้ด้วยตัวเลือก 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 ,
} ) ; เมื่อหมดเวลา APIConnectionTimeoutError จะถูกส่งออกไป
โปรดทราบว่าคำขอที่หมดเวลาจะถูกลองอีกครั้งสองครั้งตามค่าเริ่มต้น
แสดงรายการวิธีการใน OpenAI API เป็นแบบแบ่งหน้า คุณสามารถใช้ for await … of ไวยากรณ์เพื่อวนซ้ำรายการต่างๆ ในทุกหน้า:
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 ;
}หรือคุณสามารถขอทีละหน้าได้:
