TH ▾
รับคีย์ API

LLM Inference APIคู่มือ

LLM Inference API: การสตรีมมิง, การเรียกใช้เครื่องมือ และโหมด JSON

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

อัปเดต:

ภาพประกอบไอโซเมตริกแสดงแพ็กเก็ตข้อมูลที่ไหลจากเทอร์มินัลไปยังเกตเวย์คลาวด์ แทนการเรียก API การอนุมาน

ประเด็นสำคัญ

  1. ชี้ SDK ของ OpenAI ไปที่ https://api.llminferenceapi.com/v1, ใช้โมเดล ID uncensored และส่งคีย์ของคุณเป็นโทเคน Bearer
  2. มีเอนด์พอยต์สองรายการ: POST /v1/chat/completions และ GET /v1/models
  3. สตรีมมิง การเรียกใช้เครื่องมือ และโหมด JSON ทำงานผ่านฟิลด์คำขอมาตรฐาน
  4. คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 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 ต่ำเกินไปสำหรับเอาต์พุตที่มีโครงสร้าง

รายการตรวจสอบสั้น ๆ เมื่อเกิดข้อผิดพลาด

ปัญหาส่วนใหญ่ในวันแรกมาจากสาเหตุไม่กี่ประการ และคุณสามารถตัดสาเหตุเหล่านั้นออกตามลำดับ

  1. Base URL. ต้องลงท้ายด้วย /v1 SDK จะเพิ่ม /chat/completions ให้เอง ดังนั้น URL ที่มีเส้นทางรวมอยู่แล้วจะไม่ทำงาน
  2. หัวคีย์ คีย์ต้องอยู่ใน Authorization: Bearer ตามด้วยคีย์ การมีช่องว่างหรือบรรทัดใหม่ติดมาด้วยเป็นสาเหตุทั่วไปของข้อผิดพลาดการตรวจสอบสิทธิ์
  3. รหัสโมเดล ใช้ uncensored ให้ตรงเป๊ะ ชื่อโมเดลของผู้ขายรายอื่นไม่ถูกต้องที่นี่
  4. Request size. ขอบเขตของ body คือ 8 MB และพรอมต์รวมกับการสร้างข้อความต้องอยู่ใน 100,000 โทเคน
  5. Balance. ดูที่ X-Balance-USD header ในการตอบกลับใด ๆ เพื่อดูว่าเครดิตเป็นปัญหาหรือไม่
  6. อ้างอิง 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