สิ่งที่สตรีมมิงมอบให้คุณ
หากไม่มีสตรีมมิง API จะเก็บคำตอบทั้งหมดไว้จนกว่าโมเดลจะทำงานเสร็จ แล้วส่งเป็นบอดี้ JSON เดียว ซึ่งสำหรับคำตอบที่ยาวอาจทำให้ต้องรอหน้าจอว่างนานหลายวินาที เมื่อใช้ stream: true เซิร์ฟเวอร์จะส่งคำตอบเดียวกันเป็นชุดของอีเวนต์ขนาดเล็ก แต่ละอันมีข้อความเพียงไม่กี่ตัวอักษร และ UI ของคุณก็สามารถแสดงผลทันทีที่ได้รับ
รูปแบบการส่งข้อมูลคือ server-sent events (SSE) ผ่าน HTTP response ทั่วไป แต่ละอีเวนต์คือบรรทัดที่ขึ้นต้นด้วย data: ตามด้วย JSON chunk และสตรีมจะจบด้วย data: [DONE] โดยปกติคุณไม่จำเป็นต้องแยกวิเคราะห์ข้อมูลนี้ด้วยตนเอง เพราะ SDK ของ OpenAI จัดการให้แล้ว หากต้องการดูข้อมูลดิบ ภาพรวมสำหรับนักพัฒนา แสดงโครงสร้างของเอนด์พอยต์ และ เอกสาร API ระบุพารามิเตอร์ทั้งหมด
มีสองประเด็นที่ต้องตัดสินใจก่อนเขียนโค้ด ประการแรกคือผู้รับสตรีมคือเบราว์เซอร์ที่เชื่อมต่อกับเซิร์ฟเวอร์ของคุณ หรือเซิร์ฟเวอร์ของคุณเพียงอย่างเดียว ประการที่สองคือคุณจัดการอย่างไรเมื่อการเชื่อมต่อขาดหายไประหว่างทาง หน้าเว็บนี้ครอบคลุมทั้งสองประเด็น
Python: สตรีมมิงด้วย OpenAI SDK
ติดตั้ง SDK ด้วย pip install openai สร้าง client โดยใช้ base URL ของเรา และส่ง stream=True โมเดล ID คือ uncensored
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredllmapi.com/v1",
api_key="YOUR_KEY",
)
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about rain."}],
stream=True,
)
text = []
usage = None
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text.append(piece)
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
print("tokens:", usage)
สังเกตการป้องกัน chunk.choices and .... chunk สุดท้ายที่บรรจุข้อมูลการใช้งานอาจมีรายการ choices ว่าง และการเข้าถึงรายการนั้นจะทำให้เกิดข้อผิดพลาด การเก็บชิ้นส่วนไว้ในรายการแล้วรวมกันที่ท้ายนั้นประหยัดกว่าการต่อสตริงซ้ำๆ ในคำตอบที่ยาว
Node: การเรียกแบบเดียวกันใน JavaScript
เมื่อใช้แพ็กเกจ openai ทางการสำหรับ Node สตรีมจะเป็น async iterator ตัวอย่างนี้ใช้ ES modules
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.uncensoredllmapi.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Name three uses for a stream." }],
stream: true,
});
let full = "";
let usage = null;
for await (const chunk of stream) {
const piece = chunk.choices?.[0]?.delta?.content;
if (piece) {
full += piece;
process.stdout.write(piece);
}
if (chunk.usage) usage = chunk.usage;
}
console.log("\nusage:", usage);
หากคุณไม่ต้องการ SDK การใช้ fetch ก็ทำได้เช่นกัน: ส่ง body JSON เดียวกันพร้อม stream: true จากนั้นอ่าน response.body ด้วย TextDecoder และแยกตามบรรทัดว่าง SDK ช่วยให้คุณไม่ต้องจัดการเหตุการณ์ที่ขาดตอนตรงขอบเขตของ chunk ซึ่งเป็นข้อผิดพลาดทั่วไปใน parser ที่เขียนเอง
การอ่านการใช้งานและยอดคงเหลือ
ข้อมูลการใช้งานจะรายงานที่ท้ายสตรีม นั่นคือตัวเลขที่คุณควรบันทึกเพื่อติดตามต้นทุน เพราะเป็นค่าที่หักจากเครดิตของคุณ ที่ $0.15 ต่อ 1M input tokens และ $0.50 ต่อ 1M output tokens คำตอบที่มี input tokens 1,200 และ output tokens 800 มีค่าใช้จ่าย 1,200 x 0.15 / 1,000,000 + 800 x 0.50 / 1,000,000 = $0.00018 + $0.0004 = $0.00058
ทุก response จะมี header X-Balance-USD พร้อมเครดิตคงเหลือ ทำให้คุณสามารถแสดงคำเตือนเมื่อเครดิตต่ำได้โดยไม่ต้องทำคำขอเพิ่ม คุณสามารถเรียก GET /v1/balance ตามช่วงเวลาได้เช่นกัน คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกคิดเงิน ซึ่งหมายความว่าข้อผิดพลาดก่อน token แรกจะไม่เสียค่าใช้จ่าย
header ของ response เดียวกันนี้ยังรวมถึง X-Request-Id ด้วย ให้บันทึกค่านี้ไว้ถัดจาก log line ของคุณสำหรับแต่ละสตรีม หากสตรีมทำงานผิดปกติ ID นี้คือสิ่งที่คุณให้ฝ่ายสนับสนุนเพื่อใช้ค้นหาคำขอนั้น
สตรีมที่ขาดหายและวิธีแก้ไข
สตรีมมิงอาจขาดหายได้ โทรศัพท์อาจสลับจาก Wi-Fi เป็นอินเทอร์เน็ตมือถือ proxy อาจปิดการเชื่อมต่อที่ว่างอยู่ หรือผู้ใช้อาจปิดแท็บ ควรวางแผนเรื่องนี้ตั้งแต่เริ่มต้น
เก็บข้อความบางส่วนไว้
เพิ่มชิ้นส่วนแต่ละชิ้นลงใน buffer เมื่อได้รับ และบันทึก buffer เมื่อลูปสิ้นสุดหรือเกิด exception หากสตรีมมิงล้มเหลว คุณจะมีคำตอบครึ่งหนึ่งที่ใช้งานได้ แสดงผลพร้อมปุ่มลองใหม่แทนที่จะทิ้งไป
ลองใหม่หรือดำเนินการต่อ
วิธีแก้ไขที่ง่ายที่สุดคือการส่งคำขอเดิมอีกครั้ง สำหรับคำตอบสั้นๆ วิธีนี้ใช้ได้ผลดี แต่สำหรับคำตอบยาว คุณสามารถส่งข้อความบางส่วนที่บันทึกไว้เป็นข้อความของผู้ช่วย และขอให้โมเดลดำเนินการต่อจากจุดที่หยุด ผลลัพธ์อาจไม่ตรงกับสิ่งที่สตรีมแรกควรผลิต ดังนั้นให้ถือเป็นความพยายามอย่างเต็มที่ และระบุไว้ใน UI ของคุณหากความถูกต้องเป็นสิ่งสำคัญ
ปิดสิ่งที่ละทิ้ง
คำขอแบบสตรีมจะครอบครองช่องความพร้อมใช้งานพร้อมกันจนกว่าสตรีมจะสิ้นสุด คีย์แบบเต็มอนุญาตให้ทำคำขอได้ 8 คำขอพร้อมกัน และคีย์ทดลองใช้ทำได้เพียง 2 คำขอ หากเซิร์ฟเวอร์ของคุณยังคงอ่านสตรีมสำหรับผู้ใช้ที่ออกไปแล้ว ช่องนั้นจะยังคงไม่ว่าง ให้ยกเลิกคำขอเมื่อไคลเอนต์ตัดการเชื่อมต่อ ใน Python ให้เรียก stream.close(); ใน Node ให้เรียก stream.controller.abort()
การส่งต่อสตรีมไปยังเบราว์เซอร์
อย่าใส่คีย์ API ของคุณในโค้ดเบราว์เซอร์ การตั้งค่าทั่วไปคือเอนด์พอยต์ขนาดเล็กบนเซิร์ฟเวอร์ของคุณเองที่เรียก API ด้วย stream: true และส่งต่อแต่ละชิ้นไปยังหน้าเว็บ ใน Node ด้วย Express ให้ตั้งค่า Content-Type: text/event-stream, เขียนแต่ละชิ้นเป็น data: ... ตามด้วยบรรทัดว่าง และฟังเหตุการณ์ close บนคำขอเพื่อยกเลิกการเรียก upstream บนหน้าเว็บ EventSource จัดการเอนด์พอยต์ GET ในขณะที่ fetch พร้อม reader จัดการบอดี POST ซึ่งคือสิ่งที่คุณต้องการเมื่อส่งประวัติข้อความ
เก็บประวัติข้อความบนเซิร์ฟเวอร์ของคุณหรือในบอดีคำขอ และตัดการสนทนาที่เก่าที่สุดออกเมื่อการสนทนายาวขึ้น หน้าต่างบริบทมีขนาด 100,000 โทเคนสำหรับพรอมต์รวมกับการสร้างข้อความ ซึ่งเป็นการสนทนาจำนวนมาก แต่เซสชันที่ยาวนานจะถึงขีดจำกัดนี้ในที่สุด
ขีดจำกัดอัตราขณะสตรีม
ขีดจำกัดคือ 300 คำขอต่อนาทีและ 8 คำขอพร้อมกันบนคีย์แบบเต็ม และ 60 คำขอต่อนาทีและ 2 คำขอพร้อมกันบนคีย์ทดลองใช้ การเกินขีดจำกัดจะส่ง HTTP 429 รหัสข้อผิดพลาดบอกคุณว่าชนขีดจำกัดใด: rate_limited หมายถึงคำขอมากเกินไปต่อนาที และ concurrency หมายถึงคำขอมากเกินไปพร้อมกัน เมื่อโหลดเกินชั่วคราว API จะส่ง 429 พร้อมเฮดเดอร์ Retry-After: 5
เนื่องจาก 429 มาถึงก่อนโทเคนใดๆ จะถูกสตรีม ให้จัดการปัญหาก่อนที่คุณจะเริ่มอ่าน ตัวห่อหุ้มการลองซ้ำเล็กน้อยก็เพียงพอแล้ว:
import time
from openai import OpenAI, RateLimitError
client = OpenAI(base_url="https://api.uncensoredllmapi.com/v1", api_key="YOUR_KEY")
def open_stream(messages, tries=4):
for n in range(tries):
try:
return client.chat.completions.create(
model="uncensored", messages=messages, stream=True
)
except RateLimitError as e:
wait = 5 if n == 0 else 5 * (n + 1)
time.sleep(wait)
raise RuntimeError("still rate limited")
สำหรับแอปแชทที่มีผู้ใช้จำนวนมาก การแก้ไขที่แท้จริงสำหรับข้อผิดพลาด concurrency คือคิวขนาดเล็กฝั่งของคุณที่อนุญาตสตรีมมิงได้ไม่เกิน 8 สตรีมมิงในเวลาเดียวกัน
รายการตรวจสอบก่อนส่งแอปแชทแบบสตรีมมิง
- ป้องกัน
choicesว่างในบล็อกสุดท้าย - เก็บข้อความบางส่วนเข้าบัฟเฟอร์และบันทึกไว้เมื่อเกิดข้อผิดพลาด
- ยกเลิกคำขอฝั่งต้นทางเมื่อเบราว์เซอร์ตัดการเชื่อมต่อ
- จำกัดสตรีมสดที่ขีดจำกัดความพร้อมใช้งานพร้อมกันของคุณ
- บันทึกการใช้งานและ ID คำขอต่อสตรีม
- ปิดการบัฟเฟอร์การตอบกลับที่พร็อกซีย้อนกลับด้านหน้าเซิร์ฟเวอร์ของคุณ มิฉะนั้นโทเคนจะมาถึงเป็นชุด
จุดสุดท้ายนี้ทำให้การปรับใช้ครั้งแรกหลายแห่งผิดพลาด ตัวอย่างเช่น Nginx จะเก็บบัฟเฟอร์การตอบกลับที่ส่งผ่านโดยค่าเริ่มต้น ทำให้สตรีมมิงทำงานบน localhost และดูเหมือนค้างในสภาพแวดล้อมการผลิตจนกว่าจะปิดการเก็บบัฟเฟอร์สำหรับเส้นทางนั้น สำหรับผลลัพธ์ JSON แทนข้อความทั่วไป ดูหมายเหตุเกี่ยวกับ โหมด JSON เพื่อลองใช้โค้ดข้างต้น สร้างคีย์ API; บัญชีใหม่สามารถขอเครดิตทดลองใช้ $0.50 ได้ด้วยการคลิกครั้งเดียว ใช้ได้ 7 วัน การเติมเงินรับเฉพาะคริปโต (USDT บน TRC20 หรือ USDC บน Base) เริ่มต้น $20
