TH ▾
รับคีย์ API

LLM API ใน Python: แชท สตรีมมิง และการเรียกใช้เครื่องมือ

คู่มือ LLM API Python นี้ใช้ OpenAI SDK ชี้ไปยังเอนด์พอยต์ที่เข้ากันได้กับ OpenAI คุณจะได้ตัวอย่างการเรียกครั้งแรก สตรีมมิง การเรียกใช้เครื่องมือ และตรรกะการรีเทรยในโค้ดที่คัดลอกและรันได้ทันที

อัปเดต

แถบบล็อกโค้ดไหลจากแล็ปท็อปไปยังฟองแชท แสดงภาพการเรียก LLM API ด้วย Python
01

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

  • ติดตั้ง openai ตั้งค่า base URL และคีย์ แล้วใช้โมเดล ID uncensored
  • สตรีมด้วย stream=True และปิดสตรีมเร็วเพื่อปลดปล่อยช่องการทำงานพร้อมกัน
  • การเรียกใช้เครื่องมือจะส่งอาร์กิวเมนต์ที่คุณต้องแยกวิเคราะห์และตรวจสอบก่อนดำเนินการใดๆ
  • จัดการ 429 ด้วย Retry-After และจำกัดคำขอพร้อมกันไว้ที่ 8 สำหรับคีย์เต็ม

ติดตั้ง SDK และทำการเรียกใช้ครั้งแรก

หากคุณต้องการการตั้งค่า llm api python ที่ใช้งานได้ภายในห้านาที OpenAI SDK คือสิ่งที่คุณต้องการ API เข้ากันได้กับ OpenAI ดังนั้นคุณจึงใช้ไคลเอนต์ทางการต่อไปและเปลี่ยนค่าสองค่า: base URL และคีย์ API ID ของโมเดลคือ uncensored

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

pip install openai
export LLM_API_KEY="your-key-here"

ตอนนี้โปรแกรมที่เล็กที่สุดแต่ใช้งานได้:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.llmmodelsapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)

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

นั่นคือการผสานรวมทั้งหมด resp.usage ให้จำนวนโทเคนของพรอมต์และจำนวนโทเคนของคอมพลีชัน ซึ่งคุณสามารถคูณด้วยอัตราใน หน้าราคา ($0.15 ต่อ 1M โทเคนอินพุต, $0.50 ต่อ 1M โทเคนเอาต์พุต) เพื่อดูว่าแต่ละคำขอมีค่าใช้จ่ายเท่าใด เอนด์พอยต์เดียวกันยังรองรับ POST /v1/responses หากโค้ดของคุณใช้รูปแบบนั้นอยู่แล้ว และ GET /v1/models แสดงรายการ ID ของโมเดล

ลักษณะของคำขอและการตอบกลับ

ไคลเอนต์ OpenAI ซ่อนรายละเอียด HTTP ไว้ แต่การรู้รายละเอียดเหล่านี้มีประโยชน์เมื่อเกิดข้อผิดพลาด SDK จะส่ง POST ไปยัง /v1/chat/completions พร้อม bearer token คุณสามารถจำลองการเรียกนี้ด้วย curl และเปรียบเทียบได้

curl https://api.llmmodelsapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'

พารามิเตอร์ที่มีประโยชน์ซึ่งส่งผ่านไปยังโมเดล: temperature, top_p, stop, seed และค่าปรับความถี่และการปรากฏ max_tokens เป็นค่าเลือกได้ หากไม่ระบุ การสร้างข้อความอาจใช้พื้นที่ที่เหลือของหน้าต่างบริบท 100,000 โทเคน (รวมพรอมต์และการสร้างข้อความ)

หัวตอบกลับสองรายการที่ควรบันทึกในการเรียกใช้ทุกครั้ง: X-Request-Id สำหรับคำถามด้านสนับสนุน และ X-Balance-USD สำหรับเครดิตคงเหลือของคุณ ด้วย SDK ของ Python คุณสามารถเข้าถึงผ่าน response ดิบ:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Ping"}],
    max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

สตรีมมิงโทเคนเมื่อได้รับ

สำหรับอินเทอร์เฟซแชทและทุกสิ่งที่ผู้ใช้กำลังรอ ให้สตรีมคำตอบ ตั้งค่า stream=True และวนซ้ำผ่านชิ้นส่วน API ส่งชิ้นส่วนเหล่านี้ผ่านเหตุการณ์ที่ส่งจากเซิร์ฟเวอร์ และชิ้นส่วนสุดท้ายจะรวมข้อมูลการใช้งานเมื่อคุณขอ

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
    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)

รายละเอียดสองประการที่ทำให้ผู้ใช้สับสน ประการแรก ชิ้นส่วนบางรายการมีรายการ choices ว่าง (เช่น ชิ้นส่วนการใช้งาน) ดังนั้นควรป้องกันข้อผิดพลาดก่อนการเข้าถึงดัชนี ประการที่สอง คำขอแบบสตรีมจะยึดช่องการทำงานพร้อมกันจนกว่าสตรีมจะสิ้นสุด หากคุณเปิดสตรีมและละทิ้งโดยไม่ปิด ช่องนั้นจะยังคงใช้งานอยู่และคำขอในภายหลังอาจล้มเหลวด้วยข้อผิดพลาด concurrency ใช้สตรีมในบล็อก with หรือเรียก stream.close() เมื่อคุณหยุดอ่านก่อนกำหนด

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

การเรียกใช้เครื่องมือกับโมเดล

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

import json

def get_order_status(order_id: str) -> str:
    # Replace with a real lookup
    return json.dumps({"order_id": order_id, "status": "shipped"})

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, 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)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": get_order_status(**args),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

ในการเขียนโค้ดจริง ให้แยกวิเคราะห์ call.function.arguments เป็น JSON ภายในบล็อก try เสมอ เนื่องจากโมเดลอาจสร้างอาร์กิวเมนต์ที่ไม่ตรงกับสคีมาของคุณ ตรวจสอบก่อนดำเนินการใดๆ ที่มีผลข้างเคียง สำหรับลูปของเอเยนต์ที่ยาวขึ้น ดู คู่มือการใช้ API นี้สำหรับเอเยนต์

การเรียกใช้เครื่องมือก็สตรีมได้เช่นกัน: อาร์กิวเมนต์มาถึงเป็นชิ้นส่วนใน delta.tool_calls และคุณต่อพ่วงตามดัชนีจนกว่าสตรีมจะเสร็จสิ้น

โหมด JSON สำหรับผลลัพธ์ที่มีโครงสร้าง

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
        {"role": "user", "content": "The setup took ten minutes and everything just worked."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])

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

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

คีย์แบบเต็มอนุญาตให้ทำคำขอพร้อมกัน 8 คำขอและ 300 คำขอต่อนาที คีย์แบบทดลองอนุญาตให้ทำคำขอพร้อมกัน 2 คำขอและ 60 คำขอต่อนาที การทำเกินกว่านี้จะทำให้ได้ HTTP 429 รหัสข้อผิดพลาดจะระบุขีดจำกัดที่คุณเกิน: rate_limited สำหรับคำขอต่อนาที และ concurrency สำหรับคำขอพร้อมกันมากเกินไป ในกรณีการรับภาระชั่วคราว คุณยังได้รับ 429 พร้อมหัว Retry-After: 5

OpenAI SDK ลองใหม่สำหรับข้อผิดพลาดบางรายการแล้ว แต่คุณควรตั้งค่านโยบายเอง:

import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)

def ask(messages, tries=5):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("gave up after retries")

หากคุณกระจายงานด้วยเธรดหรือ asyncio จำกัดพูลที่ 8 (หรือ 2 บนคีย์ทดลอง) ด้วยซีมาฟอร์ นั่นช่วยให้คุณอยู่ภายใต้ขีดจำกัดความพร้อมใช้งานพร้อมกันโดยไม่ต้องพึ่งพาการลองใหม่ คำขอที่ล้มเหลวหรือปฏิเสธไม่มีการเรียกเก็บเงิน ดังนั้นการลองใหม่จึงไม่เสียค่าใช้จ่ายเพิ่มเติมสำหรับความพยายามที่ล้มเหลว

ตรวจสอบยอดคงเหลือจากโค้ดด้วย GET /v1/balance หรืออ่าน X-Balance-USD จากคำตอบใด ๆ รายการพารามิเตอร์เต็มรูปแบบอยู่ใน เอกสาร API

ต้นทุนในการรันตัวอย่างเหล่านี้

ตัวอย่างข้างต้นมีขนาดเล็ก การเรียกด้วย 300 โทเคนพรอมต์และ 200 โทเคนการสร้างข้อความมีค่าใช้จ่าย 300 x $0.15 / 1M บวก 200 x $0.50 / 1M ซึ่งคือ $0.000045 บวก $0.0001 หรือ $0.000145 ประมาณ 6,900 คำขอเช่นนี้พอดีกับ $1 เครดิตทดลองใช้ $0.50 ครอบคลุมประมาณ 3,400 คำขอเหล่านี้ และมีอายุการใช้งาน 7 วันโดยไม่ต้องใช้รายละเอียดการชำระเงิน

หลังจากทดลอง เติมเงินจำนวนเต็มใดๆ ตั้งแต่ $20 ถึง $500 พร้อมโบนัส 5% จาก $50, 10% จาก $100 และ 15% จาก $200 เครดิตไม่หมดอายุและไม่มีบริการแบบสมาชิก พรอมต์ไม่ถูกใช้สำหรับการฝึกอบรม

02

ถาม-ตอบ

สามารถใช้ไลบรารี Python ทางการของ OpenAI ได้หรือไม่

ได้ กำหนด base_url เป็นที่อยู่ API และ api_key เป็นคีย์ของคุณ แล้วเรียก chat.completions.create โดยระบุโมเดล uncensored

API รองรับ Python แบบ async หรือไม่

ได้ ใช้ AsyncOpenAI พร้อม base URL และคีย์เดียวกัน โดยจำกัดจำนวนงานพร้อมกันให้ไม่เกิน 8 สำหรับคีย์เต็ม หรือ 2 สำหรับคีย์ทดลอง

ฉันจะดูจำนวนโทเคนที่ใช้ในการเรียกใช้ได้อย่างไร

อ่าน resp.usage ในการเรียกปกติ หรือส่ง stream_options พร้อม include_usage ในการเรียกแบบสตรีม คูณด้วย $0.15 ต่อ 1M input tokens และ $0.50 ต่อ 1M output tokens

พรอมต์ของฉันมีความยาวได้สูงสุดแค่ไหน?

หน้าต่างบริบทรองรับ 100,000 token รวม prompt และ completion ขนาด request body จำกัดที่ 8 MB

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ เปลี่ยน URL พื้นฐาน นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API