API ของ OpenAI สำหรับนักพัฒนา: ใช้เอนด์พอยต์ที่เข้ากันได้

สรุปสั้นๆ

คู่มือส่วนใหญ่เกี่ยวกับ openai api สำหรับนักพัฒนา มักสมมติว่ามีผู้ให้บริการรายเดียวและใบแจ้งหนี้รายเดียว แต่รูปแบบการสื่อสารคือ JSON ผ่าน HTTPS เท่านั้น และโค้ดไคลเอนต์ กรอบงาน และเครื่องมือจำนวนมากสามารถสื่อสารกับเซิร์ฟเวอร์ใดๆ ที่รองรับรูปแบบนี้ได้ เว็บไซต์นี้โฮสต์เซิร์ฟเวอร์ดังกล่าว คุณสามารถใช้ SDK เดิม เปลี่ยน URL พื้นฐาน สลับคีย์ API จากเว็บไซต์นี้ และตั้งค่าโมเดลเป็น uncensored

นี่คือการย้ายแอปพลิเคชันทั่วไปทั้งหมด นี่คือรายการตรวจสอบ และส่วนที่เหลือของหน้าเว็บจะอธิบายแต่ละขั้นตอน

1. สร้างบัญชีและรับเครดิตทดลองใช้บน หน้าคีย์ API
2. ตั้งค่า base URL เป็น https://api.openaigatewayapi.com/v1
3. ส่งคีย์ในรูปแบบ Authorization: Bearer <key> SDK จะจัดการส่วนนี้ให้คุณเมื่อคุณส่งค่า api_key
4. ใช้ uncensored เป็น ID โมเดลในทุกคำขอ
5. จัดการ HTTP 429 ด้วยการลองใหม่แบบสั้นๆ ตามที่แสดงในส่วนท้าย

มีเอนด์พอยต์สองจุด: POST /v1/chat/completions และ GET /v1/models บริการรองรับเฉพาะข้อความ ไม่มีสร้างภาพหรือเสียง ไม่มี embeddings และไม่มี fine-tuning ดังนั้นหากแอปของคุณเรียกใช้ฟีเจอร์เหล่านั้น คุณจะต้องใช้ผู้ให้บริการอื่น

ตรวจสอบการเชื่อมต่อด้วย curl

ก่อนแก้ไขแอปพลิเคชันของคุณ ให้ยืนยันว่าคีย์ใช้งานได้ เอนด์พอยต์โมเดลเป็นวิธีทดสอบที่ประหยัดที่สุดเพราะไม่สร้างโทเคน

Copyexport API_KEY="paste-your-key-here"

curl https://api.openaigatewayapi.com/v1/models \
  -H "Authorization: Bearer $API_KEY" | grep -o uncensored

คำสั่ง grep จะพิมพ์โมเดล ID uncensored หากในรายการมีโมเดลนี้; ลบ grep ออกเพื่อดูรายการ JSON เต็ม หากได้รับ 401 แสดงว่าคีย์ไม่ถูกต้องหรือขาด prefix Bearer ตอนนี้ส่งคำขอจริง:

Copycurl https://api.openaigatewayapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ],
    "temperature": 0.4
  }'

การตอบสนองมีออบเจกต์ choices และ usage มาตรฐาน พร้อมเฮดเดอร์ X-Request-Id, X-Balance-USD และ X-RateLimit-Limit-* ที่แสดงขีดจำกัดคำขอและคำขอพร้อมกัน

Python ด้วยแพ็กเกจ openai อย่างเป็นทางการ

ใน Python คุณแก้ไขเฉพาะคอนสตรัคเตอร์ของไคลเอนต์ ส่วนที่เหลือคือโค้ดที่คุณมีอยู่แล้ว

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short, accurate release notes."},
        {"role": "user", "content": "Summarise: added retry logic, fixed timeout bug."},
    ],
    temperature=0.5,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

อ่านคีย์จากตัวแปรสภาพแวดล้อมในโค้ดจริง ตัวอย่างนี้กำหนดค่าคงที่ในโค้ดไว้เฉพาะเพื่อให้โค้ดตัวอย่างสั้นลงเท่านั้น max_tokens เป็นตัวเลือกที่นี่; หากคุณละไว้ การสร้างข้อความอาจใช้พื้นที่ที่เหลือของหน้าต่าง 100,000 โทเคน (พรอมต์และการสร้างข้อความรวมกัน) การตั้งค่าไว้ล่วงหน้าเป็นวิธีประหยัดเพื่อจำกัดต้นทุนเมื่อการสร้างข้อความทำงานเกินควบคุม

สตรีมมิง

สตรีมมิงใช้ Server-Sent Events และใช้แฟลก stream=True เหมือนที่คุณคุ้นเคย จำนวนการใช้งานจะปรากฏที่ท้ายสตรีม ดังนั้นชิ้นสุดท้ายอาจมีรายการ choices ว่าง

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List five edge cases for a date parser."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.total_tokens)

รายละเอียดหนึ่งอย่างสำคัญสำหรับการวางแผนความจุ คำขอแบบสตรีมจะครอบครองช่องคำขอพร้อมกันจนกว่าสตรีมจะเสร็จสิ้น ไม่ใช่จนกว่าโทเคนแรกจะมาถึง หากไคลเอนต์ทิ้งสตรีมโดยไม่ปิด ช่องนั้นจะไม่ว่างนานกว่าที่คุณคาด

ตัวอย่าง Node.js

Node SDK ใช้การตั้งค่าสองอย่างเดียวกันแต่ใช้ชื่อต่างกัน

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.openaigatewayapi.com/v1",
  apiKey: process.env.GATEWAY_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "user", content: "Write a regex that matches ISO 8601 dates, and explain it." },
  ],
  temperature: 0.3,
});

console.log(completion.choices[0].message.content);

หากคุณใช้เฟรมเวิร์กที่มีการผสานรวม OpenAI เป็นของตัวเอง ให้มองหาฟิลด์ชื่อ base URL, API base หรือ endpoint ในการตั้งค่า การวาง URL เดียวกันที่นั่นมักเป็นขั้นตอนเดียวที่จำเป็น เฟรมเวิร์กแชท เฟรมเวิร์กเอเจนต์ และปลั๊กอินของ editor ส่วนใหญ่ปฏิบัติตามรูปแบบนี้ พารามิเตอร์การสุ่มตัวอย่างเช่น temperature, top_p, stop, seed และค่าปรับความถี่และการปรากฏจะถูกส่งผ่านไปยังโมเดล

การเรียกใช้ฟังก์ชันและโหมด JSON

ฟีเจอร์สองอย่างที่กำหนดว่าโมเดลเหมาะกับแอปพลิเคชันจริงหรือไม่: การเรียกใช้ฟังก์ชันของคุณและการส่งคืนข้อมูลที่แยกวิเคราะห์ได้ รองรับทั้งสองฟีเจอร์

การเรียกใช้ฟังก์ชัน

คุณประกาศเครื่องมือด้วย tools, บังคับเลือกตัวเลือกด้วย tool_choice, และส่งผลลัพธ์กลับเป็นข้อความด้วย role: "tool" การตอบสนองแบบสตรีมส่ง tool_calls เป็นชิ้นส่วน เหมือนกับรูปแบบมาตรฐาน

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

ตรวจสอบอาร์กิวเมนต์ก่อนดำเนินการ โมเดลสร้าง JSON ที่ตรงกับสคีมาของคุณในส่วนใหญ่ ไม่ใช่ทุกครั้ง ดังนั้นให้ปฏิบัติต่อ call.function.arguments เหมือนข้อมูลที่ไม่ได้รับความไว้วางใจ

โหมด JSON

สำหรับงานการสกัดและการจัดประเภท ให้ขอวัตถุ JSON และระบุไว้ในพรอมต์ด้วย การกล่าวถึง JSON ในคำแนะนำให้ผลลัพธ์ที่ดีกว่าการพึ่งพาแฟลกเพียงอย่างเดียว

Copyfrom openai import OpenAI
import json

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"sentiment\": string, \"topics\": [string]}."},
        {"role": "user", "content": "The docs are clear but the rate limits caught me off guard."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data)

ขีดจำกัด ข้อผิดพลาด และการทำซ้ำ

คีย์เต็มจำนวนอนุญาตให้คำขอค้างได้ 8 คำขอและ 300 คำขอต่อนาที คีย์ทดลองอนุญาตให้คำขอค้างได้ 2 คำขอและ 60 คำขอต่อนาที ขนาดสูงสุดของบอดีคำขอคือ 8 MB หากเกินขีดจำกัด คุณจะได้รับ HTTP 429 และรหัสข้อผิดพลาดจะบอกคุณว่าเกินขีดจำกัดใด

รหัสข้อผิดพลาด	ความหมาย	สิ่งที่ควรทำ
rate_limited	คำขอเกินจำนวนต่อนาที	ลดความเร็วผู้ส่งหรือกระจายงานตลอดหนึ่งนาที
concurrency	คำขอพร้อมกันมากเกินไป	ลดจำนวน worker ลงเหลือ 8 หรือต่ำกว่า หรือ 2 สำหรับคีย์ทดลอง
429 พร้อม Retry-After: 5	โอเวอร์โหลดชั่วคราว	รอจำนวนวินาทีที่กำหนดแล้วลองอีกครั้ง

SDKs มีการลองใหม่สำหรับข้อผิดพลาดบางรายการ เพิ่มการจัดการของคุณเองสำหรับ 429 เพื่อให้การพุ่งของข้อมูลไม่ทำให้งานแบทช์ล้มเหลว:

Copyimport time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
    max_retries=0,
)

def ask(prompt, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            wait = float(e.response.headers.get("retry-after", 2 ** i))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน ดังนั้นลูปการเรียกซ้ำจึงไม่ทำให้บิลของคุณเพิ่มขึ้นเป็นสองเท่า การใช้ semaphore ที่ปรับขนาดตามขีดจำกัดคำขอพร้อมกันของคุณเป็นวิธีที่สะอาดที่สุดในการอยู่ภายใต้ขีดจำกัดในโค้ดแบบ async

การย้ายแอปพลิเคชันที่มีอยู่

หากคุณมีแอปที่ทำงานได้แล้ว อย่า hardcode ค่าใหม่ ให้ใส่ base URL, คีย์ และชื่อโมเดลในตัวแปรสภาพแวดล้อม เพื่อให้คุณสามารถสลับระหว่าง environment ได้โดยไม่ต้อง deploy สิ่งนี้ยังช่วยให้คุณรันชุดทดสอบเดียวกันกับ backend สองตัวและเปรียบเทียบผลลัพธ์ได้แบบ side by side

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.openaigatewayapi.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

def complete(messages, **kw):
    return client.chat.completions.create(model=MODEL, messages=messages, **kw)

จากนั้นทำงานผ่านขั้นตอนการย้ายข้อมูลสั้นๆ:

1. รันชุดพรอมต์ที่มีอยู่กับเอนด์พอยต์ใหม่และอ่านผลลัพธ์ด้วยตนเอง การตรวจสอบด้วยอัตโนมัติจับความผิดพลาดของโครงสร้าง ไม่ใช่โทนเสียง
2. ตรวจสอบว่าโค้ดที่ parse JSON ยังทำงานผ่านได้เมื่อตั้งค่า response_format และเก็บ fallback ที่ตัดข้อความแปลกๆ รอบ object ออก
3. วัดจำนวนโทเคนจริงจาก usage เพราะโมเดลที่ต่างกันแบ่งโทเคนข้อความต่างกันและประมาณการเก่าของคุณอาจคลาดเคลื่อน
4. ตั้งค่า worker pool ให้เหลือ 8 หรือน้อยกว่า เพื่อให้ขีดจำกัดคำขอพร้อมกันไม่กลายเป็นจุดล้มเหลวแรกภายใต้ภาระงาน
5. ส่งไปยังส่วนเล็กๆ ของปริมาณคำขอ, ดูอัตรา 429 และ error logs แล้วจึงขยาย

ทีมมักลืมพรอมต์ระบบในกระบวนการนี้ พรอมต์ที่เขียนเพื่อกระตุ้นโมเดลที่ปฏิเสธง่ายให้ประพฤติตัวมักมีบรรทัดที่เกี่ยงงอนซึ่งไม่จำเป็นที่นี่และอาจทำให้ผลลัพธ์รก อ่านของคุณอีกครั้งและตัดสิ่งที่ไม่มีผลอีกต่อไปออก

สิ่งที่คุณต้องรู้ก่อนเปลี่ยน

ความเข้ากันได้ครอบคลุมรูปแบบคำขอและการตอบสนอง ไม่ทำให้บริการนี้เป็น API ทางการของผู้สร้างโมเดลใดบริการหนึ่ง บริการนี้รันโมเดลแบบเปิดน้ำหนักหนึ่งโมเดล โดยผู้ให้บริการอิสระเป็นโฮสต์และปรับแต่งให้ตอบคำถามโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย บริการนี้ไม่ใช่ตัวเปลี่ยนเส้นทางข้ามผู้ผลิต ดังนั้นคุณจะไม่มีเมนูของโมเดลอื่นๆ ด้านหลัง เนื้อหาทางเพศที่เกี่ยวข้องกับผู้เยาว์ไม่อนุญาต และขีดจำกัดนี้ไม่สามารถเปลี่ยนแปลงได้

วางแผนโดยคำนึงถึงความแตกต่างในทางปฏิบัติสามประการจากแพลตฟอร์มหลายโมเดลขนาดใหญ่:

• หนึ่งโมเดล ID คือ uncensored หากโค้ดของคุณสลับโมเดลตามงาน ให้ยุบสิ่งนั้นเป็นค่าเดียว
• ข้อความเท่านั้น ลบการเรียก image, audio หรือ embedding ออกจากเส้นทางที่ไปยังเอนด์พอยต์นี้
• พฤติกรรมของพรอมต์แตกต่างกัน โมเดลอื่นอ่านคำแนะนำแตกต่างกัน ดังนั้นให้รันพรอมต์และการทดสอบของคุณอีกครั้งหลังจากเปลี่ยน การปรับแต่งพรอมต์ระบบให้กระชับเมื่อผลลัพธ์เบี่ยงเบน

พรอมต์ไม่ถูกใช้ในการฝึกฝน สำหรับรายการพารามิเตอร์ทั้งหมดดูที่ เอกสาร API หากคุณกำลังประมาณการค่าใช้จ่าย หน้า ราคา ระบุอัตราต่อโทเคน: $0.15 ต่อ 1M โทเคนอินพุต และ $0.50 ต่อ 1M โทเคนเอาต์พุต ซึ่งเรียกเก็บจากเครดิตแบบเติมเงินล่วงหน้าโดยไม่ต้องสมัครสมาชิก การเติมเงินเริ่มต้นที่ $20 ถึง $500 และเครดิตไม่หมดอายุ หากคุณกำลังพิจารณาชั้นพร็อกซีด้านหน้าบริการหลายแห่ง หน้า LLM gateways ครอบคลุมว่าเมื่อไหร่ที่ส่วนประกอบเพิ่มเติมนี้จะคุ้มค่า

คู่มือเพิ่มเติม

• อธิบาย API Gateway ของ OpenAI ด้วยภาษาที่เข้าใจง่าย
• ราคา API Gateway ของ OpenAI: ตัวอย่างต้นทุนจริง
• LLM Gateway: วิเคราะห์ต้นทุนเทียบกับความซับซ้อน