Poin utama
- Instal openai, lalu buat OpenAI(base_url=..., api_key=...) dengan model diatur ke uncensored.
- Streaming, mode JSON, dan pemanggilan fungsi menggunakan parameter standar, dan async bekerja dengan cara yang sama.
- Batasi konkurensi di angka 8 dengan semaphore dan biarkan SDK melakukan percobaan ulang respons 429.
- Baca X-Balance-USD dari header respons mentah untuk memantau kredit Anda dari kode.
Contoh kerja minimal
Berikut adalah pengaturan proxy API OpenAI Python terpendek yang berguna. Ini mengasumsikan Python 3.9 atau lebih baru, kunci dari halaman kunci API, paket terinstal dengan pip install openai dan kunci diekspor sebagai UNCENSORED_API_KEY.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.openaiapiproxy.com/v1",
api_key=os.environ["UNCENSORED_API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Give me a one-line product tagline for a hiking app."}],
temperature=0.8,
max_tokens=60,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)Endpointnya kompatibel dengan OpenAI, tetapi ini adalah layanan terpisah. Ini bukan API resmi dari OpenAI atau vendor lain, dan ini meng-host satu model, uncensored. Hanya ada dua rute: POST /v1/chat/completions dan GET /v1/models, jadi tetap gunakan antarmuka penyelesaian chat dari SDK.
Beberapa catatan tentang kode tersebut. Kunci berasal dari variabel lingkungan, bukan literal, sehingga tidak pernah masuk ke kontrol versi. Objek usage pada respons memegang jumlah token tepat yang menjadi dasar tagihan, yang berguna untuk logging. Dan max_tokens bersifat opsional: abaikan dan penyelesaian mungkin menggunakan sisa jendela, yang baik untuk cerita tetapi mahal untuk loop yang memiliki bug.
Streaming token saat tiba
Streaming menggunakan server-sent events. Berikan stream=True dan iterasi melalui chunk. Bagian terakhir stream memuat penggunaan token, jadi tangani chunk tanpa choices.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Tell a two-paragraph ghost story."}],
stream=True,
)
usage = None
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if getattr(chunk, "usage", None):
usage = chunk.usage
print()
if usage:
print("tokens:", usage.prompt_tokens, usage.completion_tokens)Satu detail operasional: panggilan streaming menempati salah satu slot konkurensi Anda hingga stream berakhir. Jika kode Anda keluar dari loop lebih awal, tutup stream (stream.close()) agar slot dibebaskan.
Aplikasi web biasanya membungkus loop ini dalam generator dan meneruskan setiap bagian ke browser. Dengan FastAPI, itu berarti mengembalikan StreamingResponse yang menghasilkan bagian teks. Simpan kunci di server dalam desain itu. Browser berbicara ke rute Anda, dan rute Anda berbicara ke API, sehingga kunci tidak pernah terekspos ke kode klien.
Klien async dan konkurensi terkontrol
Kunci penuh memungkinkan 8 permintaan sekaligus dan 300 per menit. Kunci uji coba memungkinkan 2 dan 60. Jika Anda menembakkan 200 korutin dengan asyncio.gather, Anda akan mengumpulkan error 429 dengan kode concurrency. Semaphore memperbaiki itu sebelum terjadi.
import asyncio
from openai import AsyncOpenAI
client = AsyncOpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
gate = asyncio.Semaphore(8)
async def ask(prompt: str) -> str:
async with gate:
r = await client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
max_tokens=200,
)
return r.choices[0].message.content
async def main():
prompts = [f"Write a title for chapter {i} of a sea adventure." for i in range(1, 41)]
results = await asyncio.gather(*(ask(p) for p in prompts))
for t in results:
print(t)
asyncio.run(main())Gunakan 2 sebagai ukuran semaphore saat Anda menggunakan kunci uji coba. SDK melakukan retry respons 429 dengan backoff secara default, dan max_retries meningkatkan jumlah percobaan. Untuk kelebihan beban sementara, layanan menjawab 429 dengan Retry-After: 5, yang dihormati oleh SDK.
Semaphore hanya membatasi permintaan yang sedang berjalan di dalam satu proses. Jika Anda menjalankan beberapa pekerja, bagikan batas di antara mereka: dengan kunci penuh, empat pekerja harus masing-masing menggunakan semaphore sebesar 2. Batas per menit sebesar 300 dibagi oleh semua pekerja, sehingga antrian dengan laju stabil lebih baik daripada lonjakan untuk pekerjaan offline besar. Batas body permintaan 8 MB jarang menjadi perhatian untuk chat, tetapi berlaku untuk setiap permintaan.
Mode JSON dan panggilan alat
Keduanya bekerja melalui parameter normal. Untuk mode JSON, atur response_format dan minta JSON dalam prompt.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Return JSON with keys name, mood and hook."},
{"role": "user", "content": "Invent a tavern keeper for a fantasy game."},
],
)
npc = json.loads(r.choices[0].message.content)
print(npc["name"])Pemanggilan fungsi membutuhkan satu langkah tambahan: Anda menjalankan fungsi sendiri dan mengembalikan output sebagai pesan tool.
import json
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
tools = [{
"type": "function",
"function": {
"name": "roll_dice",
"description": "Roll a die with the given number of sides.",
"parameters": {
"type": "object",
"properties": {"sides": {"type": "integer"}},
"required": ["sides"],
},
},
}]
messages = [{"role": "user", "content": "Roll a twenty-sided die for me."}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
call = msg.tool_calls[0]
sides = json.loads(call.function.arguments)["sides"]
messages.append(msg)
messages.append({"role": "tool", "tool_call_id": call.id, "content": "14"})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)Nilai yang dikembalikan untuk dadu di sini dikodekan secara tetap untuk singkatnya. Dalam kode nyata, panggil fungsi Anda dengan sides dan kirimkan hasilnya.
Dua detail lebih lanjut tentang alat. Gunakan tool_choice ketika Anda perlu memaksa fungsi tertentu alih-alih membiarkan model memutuskan. Dan pertahankan deskripsi alat agar spesifik: model memilih fungsi hanya dari nama dan deskripsinya, jadi "Gulingkan dadu dengan jumlah sisi yang diberikan" bekerja lebih baik daripada "dadu". Jika balasan berisi beberapa panggilan fungsi, jalankan semuanya dan lampirkan satu pesan tool per ID panggilan sebelum Anda meminta jawaban akhir.
Error, percobaan ulang, dan riwayat percakapan
SDK mengangkat pengecualian bertipe, yang membuat penanganan error menjadi singkat. 429 mengangkat openai.RateLimitError, kegagalan jaringan mengangkat openai.APIConnectionError, dan status tidak sukses lainnya mengangkat openai.APIStatusError. SDK sudah melakukan retry pada saat Anda melihat yang pertama, sehingga apa yang mencapai kode Anda adalah panggilan yang gagal berulang kali.
import time
import openai
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=2)
def chat(messages, attempts=4):
delay = 2.0
for n in range(attempts):
try:
r = client.chat.completions.create(model="uncensored", messages=messages)
return r.choices[0].message.content
except openai.RateLimitError as e:
wait = float(e.response.headers.get("Retry-After", delay))
time.sleep(wait)
delay *= 2
except openai.APIConnectionError:
time.sleep(delay)
delay *= 2
raise RuntimeError("gave up after repeated failures")
print(chat([{"role": "user", "content": "Name a color."}]))Kode membaca Retry-After saat layanan mengirimkannya, yang terjadi saat kelebihan beban sementara (nilainya adalah 5 detik). Saat header hilang, ia mundur sesuai jadwalnya sendiri. Perhatikan bahwa loop tidak menangkap setiap error: permintaan yang buruk tidak akan membaik dengan percobaan ulang, jadi biarkan itu merambat.
Riwayat percakapan adalah bagian lain dari status. API tidak menyimpannya untuk Anda, sehingga program Anda memiliki daftar pesan. Kebijakan sederhana yang bekerja dengan baik: pertahankan pesan sistem, pertahankan N giliran terakhir, dan ketika total tumbuh melebihi ukuran yang Anda pilih, minta model untuk meringkas bagian tertua menjadi satu pesan pendek.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
def compact(history, keep=6):
system, rest = history[0], history[1:]
if len(rest) <= keep:
return history
old, recent = rest[:-keep], rest[-keep:]
text = "\n".join(m["role"] + ": " + m["content"] for m in old)
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarize this conversation in 120 words:\n" + text}],
max_tokens=250,
)
summary = {"role": "system", "content": "Earlier in this conversation: " + r.choices[0].message.content}
return [system, summary] + recentRingkasan juga memakan token, tetapi mereka membayar sendiri: percakapan yang jika tidak akan mengirim ulang 20.000 token pada setiap giliran turun menjadi beberapa ribu.
Membaca saldo dan ID permintaan
Setiap respons mencakup X-Request-Id dan X-Balance-USD. SDK menyembunyikan header secara default, tetapi with_raw_response mengeksposnya sambil tetap memberikan objek yang telah diparsing.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance USD:", raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)Log ID permintaan dengan setiap kegagalan. Jika Anda perlu menghubungi tim melalui halaman dukungan, ID itu menunjuk langsung ke panggilan.
Header saldo berguna di luar logging. Pekerjaan terjadwal dapat membacanya setelah setiap batch dan berhenti ketika kredit turun di bawah ambang batas yang Anda atur, atau mengirim pesan kepada Anda sehingga Anda dapat mengisi ulang sebelum pengguna menyadarinya. Kredit tidak pernah kedaluwarsa, sehingga tidak ada tekanan untuk menghabiskannya. Pengisian ulang adalah jumlah utuh dari $20 hingga $500, sehingga Anda dapat mengisi ulang dalam langkah lebih besar jika Anda lebih suka.
Tanpa SDK: requests atau httpx
Jika Anda lebih memilih untuk menghindari ketergantungan, API cukup sederhana untuk klien HTTP biasa.
import requests
r = requests.post(
"https://api.openaiapiproxy.com/v1/chat/completions",
headers={"Authorization": "Bearer YOUR_KEY"},
json={
"model": "uncensored",
"messages": [{"role": "user", "content": "Name three sea shanty topics."}],
},
timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])Atur waktu tunggu yang murah hati untuk penyelesaian panjang. Model dapat menggunakan sebanyak mungkin dari jendela 100.000 token yang ditinggalkan prompt, sehingga permintaan tanpa batas untuk fiksi panjang dapat memakan waktu.
Pendekatan yang sama bekerja untuk streaming. Tambahkan "stream": true ke body JSON, berikan stream=True ke requests.post dan baca respons dengan iter_lines(). Setiap baris peristiwa dimulai dengan data: diikuti oleh JSON, dan stream berakhir dengan penanda data: [DONE]. Menguraikannya secara manual adalah latihan pembelajaran yang baik, meskipun untuk kode produksi SDK melakukannya dengan lebih sedikit kasus tepi, seperti baris parsial dan sambungan ulang.
Penganggaran di dalam kode Python Anda
Hitungan token di resp.usage memungkinkan Anda menghitung pengeluaran per panggilan. Harganya adalah $0,15 per 1M token input dan $0,50 per 1M token output.
from openai import OpenAI
client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")
def cost_usd(prompt_tokens: int, completion_tokens: int) -> float:
return prompt_tokens * 0.15 / 1_000_000 + completion_tokens * 0.50 / 1_000_000
r = client.chat.completions.create(model="uncensored", messages=[{"role": "user", "content": "Hi"}])
print(cost_usd(r.usage.prompt_tokens, r.usage.completion_tokens))
print(cost_usd(1_000_000, 200_000)) # 0.25Baris kedua diperiksa secara manual: 1M token input berharga $0,15 dan 200.000 token output berharga 0,2 x $0,50 = $0,10, yang menjadikan $0,25. Permintaan yang gagal atau ditolak tidak dikenakan biaya, sehingga Anda tidak perlu mengurangkan mereka. Pengisian ulang dimulai dari $20, dan halaman harga mencantumkan bonus sebesar $50, $100, dan $200.
Untuk daftar parameter lengkap dan kode error, lihat dokumentasi.
Pertahankan total berjalan di pekerjaan Anda sehingga loop tidak dapat menghabiskan lebih dari yang Anda rencanakan. Pekerjaan batch yang mengklasifikasikan 50.000 teks pendek pada 400 token input dan 20 token output masing-masing menggunakan 20M token input dan 1M token output. Itu berharga 20 x $0,15 + 1 x $0,50 = $3,50. Jika penghitung Anda mengatakan pekerjaan itu dua kali lipat dari itu, sesuatu sedang berputar.
