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

ประเด็นสำคัญ
- ติดตั้ง 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 ไปยังผู้ติดต่อบนเว็บไซต์ รหัสคำขอช่วยให้ผู้ดำเนินการพบการเรียกใช้ที่แน่นอนของคุณ ซึ่งจะมีประโยชน์มากกว่าคำอธิบายสิ่งที่คุณเห็น
คู่มือเพิ่มเติม
ถาม-ตอบ
ฉันต้องการ SDK พิเศษหรือไม่?
ไม่ SDK Python ของ OpenAI ใช้งานได้เมื่อคุณตั้งค่า base URL และคีย์ของคุณ
ฉันต้องใช้โมเดล ID ใด?
ใช้ uncensored คุณสามารถดูรายการ ID ที่ใช้งานได้ด้วยการเรียก GET /v1/models
สามารถรันคำขอพร้อมกันได้กี่คำขอ?
คีย์แบบเต็มอนุญาตให้ใช้คำขอพร้อมกัน 8 คำขอ และ 300 คำขอต่อนาที ส่วนคีย์ทดลองอนุญาตให้ใช้ 2 และ 60
สตรีมมิงทำงานใน SDK Python ได้หรือไม่?
ใช่ ส่ง stream=True และวนซ้ำผ่านส่วนข้อมูล การใช้งานจะรายงานที่ท้ายสตรีม
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด