Alur Kerja API LLM di Python: Penyiapan Langkah demi Langkah
Arahkan SDK OpenAI ke base URL baru, gunakan ID model uncensored, dan tambahkan retry, eksekusi paralel, dan pemanggilan fungsi secara bertahap.
Diperbarui

Poin utama
- Instal openai, atur base_url ke https://api.veo3apis.com/v1, dan gunakan model uncensored.
- Tangani 429 dengan menunggu Retry-After; permintaan yang gagal tidak dikenakan biaya.
- Sesuaikan ukuran thread pool sesuai kunci: 8 worker untuk kunci penuh, 2 untuk kunci uji coba.
- Baca X-Balance-USD dari header respons untuk melacak pengeluaran per eksekusi.
Versi singkatnya
Untuk membuat skrip alur kerja api llm python, instal SDK OpenAI resmi, atur base URL ke https://api.veo3apis.com/v1, gunakan kunci Anda sebagai kunci API, dan panggil model uncensored. Tidak ada yang lain yang berubah. Layanan ini kompatibel dengan OpenAI, sehingga setiap pola yang sudah Anda kenal dari SDK berfungsi: panggilan chat biasa, streaming, mode JSON, dan pemanggilan fungsi.
Artikel ini membangun satu alur kerja kecil secara bertahap. Anda mulai dengan satu panggilan, lalu tambahkan konfigurasi dari variabel lingkungan, pembungkus retry, runner paralel, pemanggilan fungsi, dan pelacakan saldo. Setiap lapisan pendek, dan Anda dapat berhenti pada salah satu yang memenuhi kebutuhan Anda.
Model ini adalah satu model bobot terbuka yang dijalankan oleh penyedia independen. Ini bukan API resmi dari vendor besar manapun dan ini bukan router, jadi hanya ada satu ID model yang perlu diingat. Model ini hanya menangani teks. Tidak ada generasi gambar, audio, atau video, tidak ada embedding, dan tidak ada fine-tuning.
Instal SDK dan buat panggilan pertama
Anda memerlukan Python 3.9 atau yang lebih baru. Instal SDK:
pip install openai
Buat kunci dari halaman kunci API setelah masuk dengan Google atau dengan email dan kata sandi. Halaman tersebut juga memiliki klaim satu klik senilai $0.50 kredit uji coba, berlaku selama 7 hari, satu per orang, tanpa memerlukan kartu. Kemudian jalankan panggilan terkecil yang mungkin:
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)
Jika ini mencetak teks dan objek penggunaan, autentikasi, routing, dan ID model semuanya benar. SDK mengirimkan kunci Anda sebagai Authorization: Bearer, dan permintaan dikirim ke POST /v1/chat/completions. Anda dapat memeriksa ID model mana yang dilihat oleh kunci Anda dengan client.models.list(), yang memanggil GET /v1/models.
Versi curl mentah berguna saat Anda melakukan debug dari server tanpa 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."}]}'
Simpan konfigurasi dalam satu klien
Mengkodekan kunci secara langsung dalam skrip adalah cara tercepat untuk membocorkannya ke repositori. Baca kedua nilai dari lingkungan, dan buat klien di satu tempat sehingga setiap langkah alur kerja menggunakannya bersama.
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
Dua pilihan di sini disengaja. max_retries=0 menonaktifkan mekanisme pengulangan bawaan SDK sehingga logika pengulangan di bagian berikutnya menjadi satu-satunya, yang memudahkan Anda memahami perilakunya. Waktu tunggu 120 detik memberi ruang untuk penyelesaian yang panjang; jendela konteks adalah 100.000 token untuk prompt ditambah penyelesaian, dan jawaban besar membutuhkan waktu untuk dialirkan. Parameter sampling seperti temperature, top_p, stop, seed dan penalti diteruskan melalui **kwargs seperti biasa.
Ulangi kesalahan yang tepat
Setiap alur kerja nyata akan mencapai batas laju cepat atau lambat. Kunci penuh memungkinkan 300 permintaan per menit dan 8 sekaligus. Kunci uji coba memungkinkan 60 per menit dan 2 sekaligus. Melebihi salah satu dan API mengembalikan HTTP 429. Kode kesalahan memberi tahu Anda batas mana yang Anda lewati: rate_limited untuk permintaan per menit, concurrency untuk terlalu banyak sekaligus. Selama kelebihan beban sementara, API juga mengirim 429 dengan header Retry-After: 5.
Ketiga kasus ini memiliki obat yang sama: tunggu, lalu coba lagi. Pembungkus ini menghormati header dan mundur ketika tidak ada.
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")
Hanya ulangi permintaan yang dapat berubah. Kode 400 berarti permintaan Anda salah format, dan mengirimkannya lagi akan gagal dengan cara yang sama, sehingga pembungkus melemparkan kembali setiap kesalahan klien selain 429. Permintaan yang gagal atau ditolak tidak dibebani biaya, sehingga pengulangan tidak menambah biaya.
Jalankan banyak input secara paralel
Untuk loop atas banyak input, thread pool sudah cukup. Klien SDK aman untuk dibagikan di seluruh thread. Ukur ukuran pool sesuai kunci Anda: 8 pekerja untuk kunci penuh, 2 untuk kunci uji coba.
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)
Ukuran pool tidak sama dengan laju permintaan. Delapan pekerja yang masing-masing menyelesaikan panggilan dalam setengah detik akan membuat 960 permintaan per menit, jauh melampaui 300. Jika panggilan Anda cepat, tambahkan jeda kecil atau pembatas token-bucket agar Anda tetap di bawah batas per menit. Jika panggilan Anda lambat, konkurensi adalah batas yang akan Anda temui terlebih dahulu. Permintaan streaming memegang slotnya hingga stream selesai.
Output terstruktur dan panggilan alat
Dua fitur mengubah panggilan chat menjadi langkah alur kerja yang dapat diandalkan oleh kode lain. Mode JSON menjamin output yang dapat diuraikan. Pemanggilan alat memungkinkan model meminta kode Anda untuk melakukan sesuatu dan kemudian menggunakan jawabannya.
Mode JSON
Atur response_format menjadi objek JSON dan jelaskan kunci-kuncinya dalam prompt.
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"])
Pemanggilan alat
Deklarasikan alat dengan tools, opsional paksa pilihan dengan tool_choice, jalankan fungsi sendiri dan kirimkan hasilnya kembali sebagai pesan dengan 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)
Selalu periksa apakah tool_calls ada sebelum membacanya. Model mungkin menjawab langsung, dan kode Anda harus menangani kedua hasil tersebut.
Rangkai langkah menjadi pipeline
Alur kerja nyata jarang berhenti pada satu panggilan. Bentuk umum adalah draf, tinjau, tulis ulang: panggilan pertama menghasilkan sesuatu, yang kedua mengkritiknya terhadap daftar periksa, dan yang ketiga menerapkan kritik tersebut. Setiap langkah adalah permintaan terpisah dengan pesan sistemnya sendiri, yang menjaga instruksi tetap pendek dan kegagalan mudah dilokalisasi.
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)
Perhatikan suhu yang lebih rendah pada langkah tinjauan. Kritik harus konsisten dari eksekusi ke eksekusi, sedangkan penyusunan manfaat dari beberapa variasi. Jika Anda menjalankan pipa ini untuk banyak masukan, masukkan seluruh fungsi tiga langkah ke dalam pekerja thread-pool dari bagian sebelumnya, sehingga setiap pekerja memiliki satu item dari awal hingga akhir dan batas 8 permintaan tetap dihormati.
Simpan hasil antara. Ketika teks akhir salah, draf dan tinjauan memberi tahu Anda langkah mana yang gagal, dan Anda dapat memperbaiki satu pesan sistem daripada menulis ulang seluruh pipeline. Menulis setiap langkah ke file baris-JSON dengan input, tiga output, dan ID permintaan membuatnya mudah, dan itu memberi Anda titik resume jika proses berhenti di tengah jalan.
Lacak saldo dan ID permintaan
Setiap respons membawa header yang layak dicatat: X-Request-Id mengidentifikasi panggilan jika Anda menghubungi dukungan, X-Balance-USD menunjukkan sisa saldo Anda, dan dua header X-RateLimit-Limit melaporkan batas permintaan dan konkurensi untuk kunci Anda. SDK menyembunyikan header secara default; gunakan pembungkus respons mentah untuk membacanya.
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)
Harga adalah $0,15 per juta token input dan $0,50 per juta token output, sehingga panggilan dengan 1.000 input dan 500 token output berharga $0,00015 + $0,00025 = $0,0004. Alur kerja yang menjalankan 5.000 panggilan seperti itu menghabiskan $2,00. Cetak saldo di awal dan akhir eksekusi, dan Anda akan mengetahui biaya setiap batch tanpa alat tambahan. Untuk tarif dan bonus isi ulang, lihat halaman harga; untuk setiap parameter yang didukung, baca dokumentasi API.
Kebiasaan lain yang layak diadopsi: simpan prompt di luar log Anda kecuali Anda membutuhkannya. Prompt yang dikirim ke API ini tidak digunakan untuk pelatihan, tetapi file log Anda sendiri adalah tanggung jawab Anda.
Pemecahan masalah penyiapan baru
Kebanyakan masalah pertama kali berasal dari daftar penyebab singkat.
- Panggilan menggantung atau mengalami kesalahan saat terhubung. Periksa URL dasar. Itu harus diakhiri dengan
/v1, dan SDK menambahkan/chat/completionssendiri. Jalur ganda adalah kesalahan umum. - Kesalahan autentikasi. Kunci hilang, terpotong atau memiliki spasi atau baris baru yang tersesat dari hasil salin-tempel. Cetak panjangnya, bukan kuncinya sendiri, dan bandingkan dengan apa yang ditunjukkan halaman kunci.
- Model tidak ditemukan. ID model adalah
uncensored, dalam huruf kecil. Panggil endpoint model untuk melihat persis apa yang dapat digunakan oleh kunci Anda. - Kode 429 konstan pada skrip kecil. Anda mungkin menggunakan kunci uji coba, yang mengizinkan 2 permintaan konkuren dan 60 per menit. Turunkan pool menjadi 2 worker, atau isi saldo untuk mendapatkan kunci penuh.
- Jawaban terpotong.
max_tokensyang rendah mengakhiri balasan lebih awal. Naikkan nilainya, atau hapus dan biarkan penyelesaian menggunakan sisa jendela. - Permintaan terlalu besar. Batas body adalah 8 MB, dan jendela token adalah 100.000 token untuk prompt dan penyelesaian secara bersamaan. Bagi input besar menjadi bagian-bagian dan proses sebagai panggilan terpisah.
Ketika sesuatu terlihat salah di sisi layanan, kirimkan nilai dari X-Request-Id ke kontak di situs. ID permintaan memungkinkan operator menemukan panggilan tepat Anda, yang jauh lebih berguna daripada deskripsi apa yang Anda lihat.
Panduan lainnya
Tanya jawab
Apakah saya memerlukan SDK khusus?
Tidak. SDK Python OpenAI resmi berfungsi begitu Anda mengatur base URL dan kunci Anda.
ID model mana yang harus saya gunakan?
Gunakan uncensored. Anda dapat mencantumkan ID yang tersedia dengan GET /v1/models.
Berapa banyak permintaan yang dapat berjalan secara paralel?
Kunci penuh mengizinkan 8 permintaan paralel dan 300 per menit. Kunci uji coba mengizinkan 2 dan 60.
Apakah streaming berfungsi di SDK Python?
Ya. Teruskan stream=True dan iterasi melalui potongan data. Penggunaan dilaporkan di akhir stream.
Kunci Anda hanya selangkah lagi dari satu formulir
Buat akun, salin kunci, ubah URL dasar. Itu saja seluruh proses pengaturannya.