TH ▾
รับคีย์ API

เวิร์กโฟลว์ LLM API ใน Python: การตั้งค่าทีละขั้นตอน

ชี้ OpenAI SDK ไปที่ URL ฐานใหม่ ใช้ id โมเดล uncensored และเพิ่มการลองใหม่ คำขอพร้อมกัน และการเรียกใช้ฟังก์ชันทีละชั้น

อัปเดต

ภาพรวมของบล็อกเรืองแสงที่มีบล็อกข้อมูลแยกออกเป็นช่องทางขนาน แสดงถึงเวิร์กโฟลว์ LLM ใน Python

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

  • ติดตั้ง openai ตั้งค่า base_url เป็น https://api.veo3apis.com/v1 และใช้โมเดล uncensored
  • จัดการ 429 โดยรอ Retry-After; คำขอที่ล้มเหลวจะไม่ถูกคิดเงิน
  • ปรับขนาด thread pool ให้เหมาะกับคีย์: 8 workers สำหรับคีย์เต็ม, 2 สำหรับคีย์ทดลอง
  • อ่าน X-Balance-USD จาก response headers เพื่อติดตามค่าใช้จ่ายต่อการรัน

สรุปสั้นๆ

เพื่อสร้างสคริปต์ Python สำหรับเวิร์กโฟลว์ API LLM ให้ติดตั้ง OpenAI SDK อย่างเป็นทางการ ตั้งค่า base URL เป็น https://api.veo3apis.com/v1 ใช้คีย์ของคุณเป็น API key และเรียกใช้โมเดล uncensored สิ่งอื่นไม่มีการเปลี่ยนแปลง บริการนี้เข้ากันได้กับ OpenAI ดังนั้นแพทเทิร์นที่คุณคุ้นเคยจาก SDK จึงใช้งานได้: การเรียกแชทธรรมดา สตรีมมิง โหมด JSON และการเรียกใช้ฟังก์ชัน

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

โมเดลเป็นโมเดลแบบเปิดน้ำหนักหนึ่งตัวที่ให้บริการโดยผู้ให้บริการอิสระ ไม่ใช่ API ทางการของผู้ขายรายใหญ่ใดๆ และไม่ใช่ router ดังนั้นจึงมีเพียง ID โมเดลเดียวที่ต้องจำ มันรองรับเฉพาะข้อความ ไม่มี generation รูปภาพ เสียง หรือวิดีโอ ไม่มี embeddings และไม่มี fine-tuning

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

คุณต้องการ Python 3.9 ขึ้นไป ติดตั้ง SDK:

pip install openai

สร้างคีย์จาก หน้า API key หลังจากเข้าสู่ระบบด้วย Google หรืออีเมลและรหัสผ่าน หน้านี้ยังมีปุ่มคลิกเดียวเพื่อรับเครดิตทดลองใช้ $0.50 ซึ่งใช้ได้ 7 วัน จำกัด 1 คนต่อราย ไม่จำเป็นต้องใช้บัตร จากนั้นเรียก API ขนาดเล็กที่สุด:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "List three uses for a hosted text API."},
    ],
)

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

หากพิมพ์ข้อความและวัตถุ usage ได้ แสดงว่า authentication, routing และ model ID ถูกต้อง SDK ส่งคีย์ของคุณเป็น Authorization: Bearer และคำขอไปที่ POST /v1/chat/completions คุณสามารถตรวจสอบ model IDs ที่คีย์ของคุณเห็นด้วย client.models.list() ซึ่งเรียก GET /v1/models

เวอร์ชัน curl ดิบมีประโยชน์เมื่อคุณดีบักจากเซิร์ฟเวอร์ที่ไม่มี Python:

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

เก็บการกำหนดค่าไว้ใน client เดียว

การ hardcode คีย์ในสคริปต์เป็นวิธีที่เร็วที่สุดในการรั่วไหลของคีย์ไปยัง repository อ่านค่าทั้งสองจาก environment และสร้าง client ในที่เดียวเพื่อให้ทุกขั้นตอนของ workflow ใช้ร่วมกัน

import os
from openai import OpenAI

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

MODEL = "uncensored"


def ask(system: str, user: str, **kwargs) -> str:
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        **kwargs,
    )
    return resp.choices[0].message.content

สองตัวเลือกนี้ตั้งใจไว้ max_retries=0 ปิดการ retries ภายในของ SDK เพื่อให้ตรรกะการ retries ในส่วนถัดไปเป็นเพียงตัวเดียว ซึ่งทำให้เข้าใจพฤติกรรมได้ง่ายขึ้น ระยะเวลาหมดอายุ 120 วินาทีให้พื้นที่สำหรับ completion ยาวๆ; หน้าต่างบริบทคือ 100,000 tokens สำหรับ prompt และ completion และการตอบกลับขนาดใหญ่ใช้เวลาในการสตรีมออก พารามิเตอร์การสุ่มตัวอย่างเช่น temperature, top_p, stop, seed และค่าปรับจะส่งผ่าน **kwargs ตามปกติ

ลองใหม่เฉพาะข้อผิดพลาดที่เหมาะสม

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

ทั้งสามกรณีมีวิธีแก้เหมือนกัน: รอแล้วลองใหม่ ตัวห่อนี้เคารพ header และลดความถี่เมื่อไม่มี

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from openai import RateLimitError, APIConnectionError, APIStatusError


def call_with_retry(messages, tries=5, **kwargs):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(
                model="uncensored", messages=messages, **kwargs
            )
        except RateLimitError as err:
            wait = err.response.headers.get("Retry-After")
            time.sleep(int(wait) if wait else delay)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
        except APIStatusError as err:
            if err.status_code < 500:
                raise
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("request failed after retries")

ลองใหม่เฉพาะข้อผิดพลาดที่สามารถเปลี่ยนแปลงได้ 400 หมายถึงคำขอของคุณมีรูปแบบไม่ถูกต้อง และการส่งอีกครั้งจะล้มเหลวแบบเดียวกัน ดังนั้นตัวห่อจะ re-raise ข้อผิดพลาดของไคลเอนต์ทั้งหมดยกเว้น 429 คำขอที่ล้มเหลวหรือถูกปฏิเสธไม่มีการเรียกเก็บเงิน ดังนั้นการลองใหม่จึงไม่เสียค่าใช้จ่ายเพิ่ม

รันอินพุตจำนวนมากแบบขนาน

สำหรับการวนลูปผ่านอินพุตจำนวนมาก กลุ่มเธรดเพียงพอ ไคลเอนต์ SDK ปลอดภัยต่อการแชร์ข้ามเธรด ปรับขนาดกลุ่มให้เหมาะกับคีย์ของคุณ: 8 งาน สำหรับคีย์เต็ม, 2 สำหรับคีย์ทดลอง

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError


def summarize(text: str) -> str:
    for _ in range(5):
        try:
            resp = client.chat.completions.create(
                model="uncensored",
                messages=[
                    {"role": "system", "content": "Summarize the text in two sentences."},
                    {"role": "user", "content": text},
                ],
                max_tokens=150,
            )
            return resp.choices[0].message.content.strip()
        except RateLimitError as err:
            time.sleep(int(err.response.headers.get("Retry-After", "5")))
    return ""


documents = ["First long text...", "Second long text...", "Third long text..."]

with ThreadPoolExecutor(max_workers=8) as pool:
    summaries = list(pool.map(summarize, documents))

for s in summaries:
    print(s)

ขนาด pool ไม่เท่ากับอัตราการร้องขอ workers แปดตัวที่เสร็จสิ้นการเรียกในครึ่งวินาทีจะทำให้เกิด 960 คำขอต่อนาที ซึ่งเกิน 300 มาก หากการเรียกของคุณเร็ว ให้เพิ่ม sleep เล็กน้อยหรือ token-bucket limiter เพื่อให้ไม่เกินขีดจำกัดต่อนาที หากการเรียกของคุณช้า concurrency เป็นขีดจำกัดที่คุณจะพบก่อน คำขอแบบสตรีมจะถือช่องจนกว่าสตรีมจะเสร็จสิ้น

ผลลัพธ์ที่มีโครงสร้างและการเรียกใช้เครื่องมือ

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

โหมด JSON

ตั้งค่า response_format เป็นออบเจกต์ JSON และอธิบายคีย์ในพรอมต์

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "A short post about nightly backups."},
    ],
)
post = json.loads(resp.choices[0].message.content)
print(post["title"], post["tags"])

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

ประกาศเครื่องมือด้วย tools, บังคับเลือกตัวเลือกด้วย tool_choice, เรียกใช้ฟังก์ชันเองและส่งผลลัพธ์กลับเป็นข้อความด้วย role: "tool".

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

tools = [{
    "type": "function",
    "function": {
        "name": "word_count",
        "description": "Count the words in a piece of text.",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in 'the quick brown fox'?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
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 = {"words": len(args["text"].split())}
        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)
else:
    print(msg.content)

ตรวจสอบเสมอว่า tool_calls มีอยู่ก่อนอ่าน โมเดลอาจตอบกลับโดยตรง และโค้ดของคุณควรจัดการผลลัพธ์ทั้งสองกรณี

เชื่อมโยงขั้นตอนเป็นไพป์ไลน์

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

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

def step(system: str, user: str, temperature: float = 0.7) -> str:
    resp = client.chat.completions.create(
        model="uncensored",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        temperature=temperature,
        max_tokens=800,
    )
    return resp.choices[0].message.content.strip()


topic = "a changelog entry for a new export feature"

draft = step("Write the requested text in under 120 words.", topic)
review = step(
    "List at most three concrete problems with this text: vague wording, missing detail, wrong tone.",
    draft,
    temperature=0.2,
)
final = step(
    "Rewrite the text so it fixes every listed problem. Reply with the text only.",
    "TEXT:\n" + draft + "\n\nPROBLEMS:\n" + review,
)
print(final)

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

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

ติดตามยอดคงเหลือและรหัสคำขอ

แต่ละการตอบกลับมีเฮดเดอร์ที่ควรบันทึก: X-Request-Id ระบุการเรียกใช้หากคุณติดต่อฝ่ายสนับสนุน X-Balance-USD แสดงยอดคงเหลือของคุณ และเฮดเดอร์ X-RateLimit-Limit สองรายการรายงานขีดจำกัดอัตราและคำขอพร้อมกันสำหรับคีย์ของคุณ SDK ซ่อนเฮดเดอร์โดยค่าเริ่มต้น; ใช้ wrapper response ดิบเพื่ออ่าน

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Reply with the single word ready."}],
    max_tokens=10,
)

print("request id:", raw.headers.get("X-Request-Id"))
print("balance usd:", raw.headers.get("X-Balance-USD"))
print("req limit:", raw.headers.get("X-RateLimit-Limit-Requests"))
print("concurrency limit:", raw.headers.get("X-RateLimit-Limit-Concurrency"))

resp = raw.parse()
print(resp.choices[0].message.content)

ราคาอยู่ที่ $0.15 ต่อ 1 ล้านโทเคนอินพุต และ $0.50 ต่อ 1 ล้านโทเคนเอาต์พุต ดังนั้นการเรียกใช้หนึ่งครั้งที่มีอินพุต 1,000 โทเคนและเอาต์พุต 500 โทเคนจะมีค่าใช้จ่าย $0.00015 + $0.00025 = $0.0004 เวิร์กโฟลว์ที่รันการเรียกใช้ 5,000 ครั้งเช่นนี้จะมีค่าใช้จ่าย $2.00 พิมพ์ยอดคงเหลือที่จุดเริ่มต้นและจุดสิ้นสุดของการรัน และคุณจะทราบต้นทุนของแต่ละชุดโดยไม่ต้องใช้เครื่องมือเพิ่มเติม สำหรับอัตราและโบนัสการเติมเงิน ดูหน้าการกำหนดราคา; สำหรับพารามิเตอร์ที่รองรับทุกตัว อ่านเอกสาร API

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

การแก้ไขปัญหาการตั้งค่าใหม่

ปัญหาส่วนใหญ่ในการรันครั้งแรกมาจากสาเหตุเพียงไม่กี่อย่าง

  • การเรียกค้างหรือเกิดข้อผิดพลาดขณะเชื่อมต่อ ตรวจสอบ base URL ต้องลงท้ายด้วย /v1 และ SDK จะเพิ่ม /chat/completions ให้เอง การมีเส้นทางซ้ำเป็นข้อผิดพลาดที่พบบ่อย
  • ข้อผิดพลาดการตรวจสอบสิทธิ์ คีย์หายไป, ถูกตัด หรือมีช่องว่างหรือบรรทัดใหม่จากการคัดลอกและวาง พิมพ์ความยาวของคีย์ ไม่ใช่คีย์เอง และเปรียบเทียบกับสิ่งที่หน้าคีย์แสดง
  • ไม่พบโมเดล รหัสโมเดลคือ uncensored ในตัวพิมพ์เล็ก เรียกใช้เอนด์พอยต์ models เพื่อดูว่าคีย์ของคุณสามารถใช้โมเดลใดได้บ้าง
  • ได้สถานะโค้ด 429 ตลอดเวลาในสคริปต์ขนาดเล็ก คุณอาจใช้คีย์ทดลองซึ่งอนุญาตคำขอพร้อมกัน 2 คำขอและ 60 คำขอต่อนาที ลดพูลเหลือ 2 worker หรือเติมเงินเพื่อรับคีย์เต็ม
  • คำตอบถูกตัด ค่า max_tokens ต่ำเกินไปทำให้การตอบกลับสิ้นสุดก่อนเวลา เพิ่มค่านี้ หรือลบออกและปล่อยให้การสร้างผลลัพธ์ใช้พื้นที่ที่เหลือของหน้าต่างบริบท
  • คำขอใหญ่เกินไป ขอบเขตของบอดี้คือ 8 MB และหน้าต่างบริบทคือ 100,000 โทเคนสำหรับพรอมต์และการสร้างรวมกัน แบ่งอินพุตขนาดใหญ่เป็นชิ้นส่วนและประมวลผลเป็นการเรียกใช้แยกกัน

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

01

ถาม-ตอบ

ฉันต้องการ SDK พิเศษหรือไม่?

ไม่ SDK Python ของ OpenAI ใช้งานได้เมื่อคุณตั้งค่า base URL และคีย์ของคุณ

ฉันต้องใช้โมเดล ID ใด?

ใช้ uncensored คุณสามารถดูรายการ ID ที่ใช้งานได้ด้วยการเรียก GET /v1/models

สามารถรันคำขอพร้อมกันได้กี่คำขอ?

คีย์แบบเต็มอนุญาตให้ใช้คำขอพร้อมกัน 8 คำขอ และ 300 คำขอต่อนาที ส่วนคีย์ทดลองอนุญาตให้ใช้ 2 และ 60

สตรีมมิงทำงานใน SDK Python ได้หรือไม่?

ใช่ ส่ง stream=True และวนซ้ำผ่านส่วนข้อมูล การใช้งานจะรายงานที่ท้ายสตรีม

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

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

รับคีย์ APIอ่านเอกสาร