LLM Inference APIคู่มือ
LLM Inference API: การสตรีมมิง, การเรียกใช้เครื่องมือ และโหมด JSON
API การอนุมาน LLM ช่วยให้คุณส่งพรอมต์ผ่าน HTTPS และรับข้อความที่สร้างกลับ โดยไม่ต้องใช้ GPU ในฝั่งของคุณ หน้าเว็บนี้แสดงการตั้งค่าที่ใช้งานได้กับเอนด์พอยต์ที่เข้ากันได้กับ OpenAI ตั้งแต่คำขอแรกไปจนถึงสตรีมมิง การเรียกใช้เครื่องมือ โหมด JSON และขีดจำกัดอัตรา
อัปเดต:

ประเด็นสำคัญ
- ชี้ SDK ของ OpenAI ไปที่ https://api.llminferenceapi.com/v1, ใช้โมเดล ID uncensored และส่งคีย์ของคุณเป็นโทเคน Bearer
- มีเอนด์พอยต์สองรายการ: POST /v1/chat/completions และ GET /v1/models
- สตรีมมิง การเรียกใช้เครื่องมือ และโหมด JSON ทำงานผ่านฟิลด์คำขอมาตรฐาน
- คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 รายการและ 300 รายการต่อนาที; การตอบกลับ 429 จะบอกคุณว่าชนขีดจำกัดใด
สิ่งที่คุณต้องมีก่อนการเรียกครั้งแรก
คุณต้องมีสามสิ่ง: base URL, คีย์ และชื่อโมเดล base URL คือ https://api.llminferenceapi.com/v1 โมเดล ID คือ uncensored และคีย์ได้จาก หน้าคีย์ API หลังจากสมัครสมาชิกด้วย Google หรืออีเมลและรหัสผ่าน ผู้ใช้ใหม่สามารถขอเครดิตทดลองใช้ $0.50 ได้ด้วยคลิกเดียว ไม่ต้องใช้บัตร ใช้ได้ 7 วัน และจำกัดหนึ่งคนต่อหนึ่งบัญชี
บริการเป็นแบบข้อความเท่านั้น เปิดใช้งาน POST /v1/chat/completions และ GET /v1/models ไม่มีเส้นทาง embeddings, ไม่มีการสร้างภาพหรือเสียง และไม่มี fine-tuning ใช้โมเดล open-weight โมเดลเดียว ซึ่งให้บริการโดยผู้ให้บริการอิสระและปรับแต่งมาให้ตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานของผู้ใหญ่ที่ถูกต้องตามกฎหมาย ไม่ใช่ API ทางการของผู้ขายโมเดลใด ๆ มีกฎข้อเดียวที่เข้มงวด: เนื้อหาที่ทำให้ผู้เยาว์เป็นเพศไม่อนุญาต
เก็บคีย์ API ไว้ใน environment variable แทนที่จะอยู่ใน source code ตัวอย่างด้านล่างอ่านค่าจาก API_KEY เมื่อภาษาที่ใช้นั้นอนุญาต
คำขอครั้งแรกของคุณ
เริ่มด้วย curl เพราะจะแสดงสิ่งที่ส่งผ่านเครือข่ายอย่างชัดเจน
curl https://api.llminferenceapi.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 assistant."},
{"role": "user", "content": "List three uses of a message queue."}
],
"temperature": 0.7
}'
การตอบกลับเป็นวัตถุ chat completion ทั่วไป: choices[0].message.content เก็บข้อความ และ usage เก็บจำนวนโทเคน คุณยังสามารถดูรายการโมเดลด้วย GET /v1/models ซึ่งเป็นวิธีรวดเร็วในการยืนยันว่าคีย์และ URL ถูกต้องก่อนที่จะดีบักอย่างอื่น
ใน Python เมื่อใช้ official OpenAI SDK มีการเปลี่ยนแปลงเฉพาะส่วน constructor:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.llminferenceapi.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "List three uses of a message queue."}],
)
print(resp.choices[0].message.content)
และใน Node:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llminferenceapi.com/v1",
apiKey: process.env.API_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "List three uses of a message queue." }],
});
console.log(resp.choices[0].message.content);
การ completion อาจใช้พื้นที่ที่เหลือของหน้าต่างบริบท 100,000 โทเคนหลังจากพรอมต์ของคุณ ดังนั้น max_tokens จึงเป็นตัวเลือก กำหนดไว้เสมอเมื่อต้องการขีดจำกัดที่ชัดเจนสำหรับต้นทุนหรือความยาว พารามิเตอร์การสุ่มตัวอย่างเช่น temperature, top_p, stop, seed และค่าปรับความถี่และการปรากฏจะถูกส่งผ่าน
การตั้งค่าสองอย่างที่ควรทราบตั้งแต่เริ่มต้น seed ทำให้การสุ่มตัวอย่างทำซ้ำได้เพียงพอสำหรับการทดสอบ ซึ่งช่วยเมื่อคุณเปรียบเทียบเวอร์ชันสองเวอร์ชันของพรอมต์และต้องการให้ความแตกต่างมาจากพรอมต์มากกว่าความบังเอิญ stop รับสตริงหนึ่งหรือหลายสตริงที่จะหยุดการสร้างทันทีที่โมเดลเขียนสตริงเหล่านั้น ซึ่งเป็นวิธีประหยัดเพื่อตัดการตอบกลับที่ตัวคั่นและหลีกเลี่ยงการจ่ายสำหรับโทเคนที่คุณจะทิ้ง
การตอบกลับแบบสตรีมมิง
เมื่อใช้ stream: true เซิร์ฟเวอร์จะตอบกลับผ่าน server-sent events และส่งข้อความเป็นชิ้นเล็กๆ ผู้ใช้จะเห็นคำแรกๆ ได้เร็ว ซึ่งสำคัญสำหรับอินเทอร์เฟซแชท ข้อมูลการใช้งานจะมาถึงตอนท้ายของการสตรีม
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about a lighthouse."}],
stream=True,
stream_options={"include_usage": True},
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if chunk.usage:
print("\n", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
มีสองจุดที่มักมองข้าม ประการแรก chunk สุดท้ายสามารถแบกรับข้อมูลการใช้งานและรายการ choices ที่ว่างเปล่า ดังนั้นตรวจสอบว่า choices ไม่ว่างเปล่าก่อนการอินเดกซ์ ประการที่สอง คำขอแบบสตรีมจะยึดตำแหน่ง concurrency ไว้จนกว่าสตรีมจะสิ้นสุด หากไคลเอนต์เปิดสตรีมและไม่อ่านจนจบ ตำแหน่งนั้นจะไม่ว่างและคำขอของคุณในภายหลังอาจชนกับข้อผิดพลาด concurrency ควรปิดหรือบริโภคสตรีมให้สมบูรณ์เสมอ
การเรียกใช้เครื่องมือ
การเรียกใช้เครื่องมือช่วยให้โมเดลขอให้โค้ดของคุณรันฟังก์ชันและใช้ผลลัพธ์ คุณอธิบายฟังก์ชันใน tools อาจควบคุมการเลือกด้วย tool_choice รันสิ่งที่โมเดลร้องขอ และส่งผลลัพธ์กลับเป็นข้อความด้วย role: "tool"
import json
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-1043?"}]
first = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"order_id": args["order_id"], "status": "shipped"}
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)
ควรแยกวิเคราะห์ function.arguments อย่างระมัดระวัง มันคือสตริง JSON ที่ผลิตโดยโมเดลภาษา และในบางโอกาสอาจมีรูปแบบผิดปกติหรือมีฟิลด์ที่คุณไม่ได้กำหนดไว้ ตรวจสอบให้แน่ใจก่อนดำเนินการ โดยเฉพาะเมื่อฟังก์ชันเปลี่ยนแปลงข้อมูล การเรียกใช้เครื่องมือยังทำงานกับการสตรีมมิงได้ ซึ่งในกรณีนี้ tool_calls จะมาถึงเป็นชิ้นส่วนที่คุณต้องรวมตามดัชนีก่อนแยกวิเคราะห์
การจัดการประวัติการสนทนา
API เป็นแบบไร้สถานะ ไม่จำคำขอก่อนหน้านี้ ดังนั้นการแชทหลายรอบจึงทำงานได้เพราะโค้ดของคุณส่งรอบก่อนหน้าอีกครั้งทุกครั้ง เก็บรายการข้อความ เพิ่มข้อความใหม่ของผู้ใช้ เรียกใช้เอนด์พอยต์ แล้วเพิ่มคำตอบของผู้ช่วยก่อนรอบถัดไป
history = [{"role": "system", "content": "You are a patient writing coach."}]
def chat(user_text):
history.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(model="uncensored", messages=history)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(chat("Give me a prompt for a ghost story."))
print(chat("Make it set on a ferry."))
เนื่องจากทุกรอบส่งประวัติกลับ ข้อมูลนำเข้าจะเพิ่มขึ้นตามความยาวของการแชท หน้าต่างบริบทรองรับ 100,000 โทเคน ซึ่งเพียงพอสำหรับการสนทนาส่วนใหญ่ แต่ต้นทุนจะเพิ่มขึ้นอย่างมากก่อนถึงขีดจำกัด รูปแบบทั่วไปคือการรักษาข้อความระบบและรอบล่าสุดหลายรอบ และแทนที่รอบเก่าด้วยสรุปสั้น ๆ ที่โมเดลเขียนเอง อ่าน usage.prompt_tokens หลังจากแต่ละการเรียกเพื่อดูว่าประวัติมีขนาดใหญ่เพียงใด
โหมด JSON
เมื่อคุณต้องการเอาต์พุตที่เครื่องอ่านได้ ให้ตั้งค่า response_format เป็น {"type": "json_object"} และระบุในพรอมต์ว่าคุณต้องการ JSON การอธิบายคีย์ที่คุณคาดหวังจะทำให้ผลลัพธ์มีความเสถียรมากขึ้น
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only, using the keys title, tags and summary."},
{"role": "user", "content": "Describe a short story about a lost robot."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
โหมด JSON ทำให้เอาต์พุตแยกวิเคราะห์เป็น JSON ได้ แต่ไม่ได้บังคับใช้ schema ของคุณ ตรวจสอบคีย์ในโค้ด และเตรียมทางสำรองสำหรับกรณีที่ค่าหายไป หากการตอบกลับถูกตัดออกเนื่องจากถึงขีดจำกัดโทเคน JSON จะไม่สมบูรณ์ ดังนั้นอย่าตั้งค่า max_tokens ต่ำเกินไปสำหรับเอาต์พุตที่มีโครงสร้าง
รายการตรวจสอบสั้น ๆ เมื่อเกิดข้อผิดพลาด
ปัญหาส่วนใหญ่ในวันแรกมาจากสาเหตุไม่กี่ประการ และคุณสามารถตัดสาเหตุเหล่านั้นออกตามลำดับ
- Base URL. ต้องลงท้ายด้วย
/v1SDK จะเพิ่ม/chat/completionsให้เอง ดังนั้น URL ที่มีเส้นทางรวมอยู่แล้วจะไม่ทำงาน - หัวคีย์ คีย์ต้องอยู่ใน
Authorization: Bearerตามด้วยคีย์ การมีช่องว่างหรือบรรทัดใหม่ติดมาด้วยเป็นสาเหตุทั่วไปของข้อผิดพลาดการตรวจสอบสิทธิ์ - รหัสโมเดล ใช้
uncensoredให้ตรงเป๊ะ ชื่อโมเดลของผู้ขายรายอื่นไม่ถูกต้องที่นี่ - Request size. ขอบเขตของ body คือ 8 MB และพรอมต์รวมกับการสร้างข้อความต้องอยู่ใน 100,000 โทเคน
- Balance. ดูที่
X-Balance-USDheader ในการตอบกลับใด ๆ เพื่อดูว่าเครดิตเป็นปัญหาหรือไม่ - อ้างอิง ID คำขอ. หากติดต่อ support ให้รวมค่า
X-Request-Idจากการตอบกลับที่ล้มเหลวเพื่อให้สามารถพบคำขอนั้นได้
โปรดทราบว่า การปฏิเสธ ไม่เหมือนกับ ข้อผิดพลาด เนื่องจากโมเดลปรับแต่งเพื่อหลีกเลี่ยงการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย คุณจะเห็นการปฏิเสธน้อยกว่าบริการที่มีตัวกรอง แต่โมเดลยังคงสามารถปฏิเสธหรือให้คำตอบที่อ่อนแอต่อพรอมต์ที่คลุมเครือได้ การกำหนดข้อความระบบที่ชัดเจนกว่ามักจะแก้ไขปัญหานี้ได้ดีกว่าการเพิ่มอุณหภูมิ
ขีดจำกัด, เฮดเดอร์ และการลองใหม่
คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอ และ 300 คำขอต่อนาที ส่วนคีย์ทดลองใช้ทำคำขอพร้อมกัน 2 คำขอ และ 60 คำขอต่อนาที ขนาดของคำขอสูงสุดอยู่ที่ 8 MB แต่ละการตอบกลับมี X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests และ X-RateLimit-Limit-Concurrency ซึ่งสะดวกต่อการบันทึกข้อมูลและการแสดงยอดคงเหลือในหน้าผู้ดูแลระบบ
เมื่อคุณเกินขีดจำกัด API จะส่ง HTTP 429 กลับมา รหัสข้อผิดพลาด rate_limited หมายถึงมีการส่งคำขอเกินจำนวนต่อนาที และ concurrency หมายถึงมีการส่งคำขอพร้อมกันเกินจำนวนที่กำหนด เมื่อเกิดภาวะโอเวอร์โหลดชั่วคราว คุณจะได้รับ 429 พร้อมเฮดเดอร์ Retry-After: 5 การสร้าง wrapper สำหรับการลองใหม่แบบง่ายสามารถจัดการได้ทั้งสามกรณีนี้:
import time
from openai import RateLimitError
def ask(messages, tries=4):
for attempt in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError as e:
wait = 5 if attempt == 0 else 5 * (attempt + 1)
retry_after = getattr(e.response, "headers", {}).get("retry-after")
time.sleep(int(retry_after) if retry_after else wait)
raise RuntimeError("still rate limited after retries")
สำหรับชุดงาน worker pool ให้จำกัดขนาดของพูลให้ไม่เกินขีดจำกัดความพร้อมใช้งานของคุณ แทนที่จะพึ่งพาการลองใหม่ การใช้ worker 8 ตัวบนคีย์แบบเต็มจะพบข้อผิดพลาด concurrency น้อยมาก หากคุณพบข้อผิดพลาดที่ไม่คาดคิด บทความการแก้ไขปัญหา จะอธิบายสาเหตุที่พบบ่อย
การชำระเงิน
การเรียกเก็บเงินเป็นแบบจ่ายตามการใช้งานจากเครดิตแบบเติมเงินล่วงหน้า: $0.15 ต่อ 1M input tokens และ $0.50 ต่อ 1M output tokens ไม่มีค่าสมาชิก คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน และเครดิตไม่หมดอายุ คำขอที่มี input tokens 1,500 ตัวและ output tokens 400 ตัว มีค่าใช้จ่ายเท่ากับ 1,500 / 1,000,000 x $0.15 + 400 / 1,000,000 x $0.50 = $0.000225 + $0.0002 = $0.000425
การเติมเงินทำได้ในจำนวนเต็มตั้งแต่ $20 ถึง $500 พร้อมโบนัส 5% เมื่อเติม $50, โบนัส 10% เมื่อเติม $100 และโบนัส 15% เมื่อเติม $200 คุณสามารถชำระเงินด้วยคริปโต (USDT บน TRC20, USDC บน Base) พรอมต์ไม่ถูกนำไปใช้ในการฝึกโมเดล หน้าราคา แสดงรายละเอียดและ คู่มือเริ่มต้นอย่างรวดเร็ว ทำซ้ำขั้นตอนการตั้งค่าในรูปแบบย่อ
คู่มือเพิ่มเติม
ถาม-ตอบ
ฉันสามารถใช้ไลบรารี OpenAI ทางการกับ API นี้ได้หรือไม่
ได้ ติดตั้ง OpenAI SDK สำหรับ Python หรือ Node, ตั้งค่า base URL เป็น https://api.llminferenceapi.com/v1, ใส่คีย์ของคุณ และใช้โมเดล ID uncensored
API รองรับ function calling หรือไม่?
ได้ ส่ง tools และ tool_choice ตามต้องการ จากนั้นส่งผลลัพธ์แต่ละรายการกลับเป็นข้อความที่มี role tool รองรับ streamed tool_calls ด้วย
ข้อผิดพลาด 429 หมายถึงอะไร?
คุณเกินขีดจำกัด รหัส rate_limited หมายถึงมีการส่งคำขอเกินจำนวนต่อนาที, concurrency หมายถึงมีการส่งคำขอพร้อมกันเกินจำนวน และเฮดเดอร์ Retry-After: 5 บ่งชี้ถึงภาวะโอเวอร์โหลดชั่วคราว ให้รอแล้วลองใหม่
ฉันสามารถใช้มันสำหรับ embeddings หรือรูปภาพได้หรือไม่
ไม่ API รองรับเฉพาะข้อความและเสนอ chat completions กับรายการโมเดล
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด
รับคีย์ API