Kluczowe punkty
- Zainstaluj openai, a następnie utwórz OpenAI(base_url=..., api_key=...) z ustawionym modelem na uncensored.
- Strumieniowanie, tryb JSON i wywoływanie narzędzi używają standardowych parametrów, a asynchroniczność działa w ten sam sposób.
- Ogranicz współbieżność do 8 za pomocą semafora i pozwól SDK ponawiać odpowiedzi 429.
- Odczytaj X-Balance-USD z nagłówków odpowiedzi surowych, aby śledzić swój kredyt z kodu.
Minimalny działający przykład
Oto najkrótsza przydatna konfiguracja proxy API openai w Pythonie. Zakłada Python 3.9 lub nowszy, klucz ze strony klucz API, pakiet zainstalowany przez pip install openai oraz klucz wyeksportowany jako 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)Endpoint jest kompatybilny z OpenAI, ale to osobny serwis. Nie jest to oficjalne API OpenAI ani żadnego innego dostawcy i udostępnia jeden model, uncensored. Dostępne są tylko dwa endpointy: POST /v1/chat/completions i GET /v1/models, więc trzymaj się interfejsu uzupełnień czatu z SDK.
Niektóre uwagi do tego kodu. Klucz pochodzi ze zmiennej środowiskowej, a nie z literału, więc nigdy nie trafi do kontroli wersji. Obiekt usage w odpowiedzi zawiera dokładną liczbę tokenów, na których opiera się fakturacja, co jest przydatne przy logowaniu. A max_tokens jest opcjonalny: pomijając go, dopełnienie może wykorzystać resztę okna kontekstu, co jest OK dla opowiadań, ale kosztowne w pętli z błędem.
Strumieniowanie tokenów w miarę ich przybywania
Strumieniowanie używa zdarzeń wysyłanych przez serwer. Przekaż stream=True i iteruj po fragmentach. Ostatnia część strumienia zawiera użycie tokenów, więc obsłuż fragmenty bez wyborów.
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)Jeden szczegół operacyjny: wywołanie strumieniowe zajmuje jeden z twoich slotów współbieżności do końca strumienia. Jeśli twój kod przerwie pętlę wcześniej, zamknij strumień (stream.close()), aby zwolnić slot.
Aplikacja internetowa zwykle owija tę pętlę w generator i przesyła każdą część do przeglądarki. Z FastAPI oznacza to zwrócenie StreamingResponse, który dostarcza części tekstu. Zachowaj klucz na serwerze w tej konfiguracji. Przeglądarka rozmawia z twoją trasą, a twoja trasa rozmawia z API, więc klucz nigdy nie jest wystawiony na kod klienta.
Klienci asynchroniczni i kontrola współbieżności
Pełny klucz pozwala na 8 żądań naraz i 300 na minutę. Klucz próbny pozwala na 2 i 60. Jeśli uruchomisz 200 korutyn z asyncio.gather, zbierzesz błędy HTTP 429 z kodem concurrency. Semafor naprawia to przed wystąpieniem.
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())Użyj 2 jako rozmiaru semafora, gdy jesteś na kluczu próbnym. SDK domyślnie ponawia odpowiedzi 429 z wycofaniem, a max_retries zwiększa liczbę prób. Przy tymczasowym przeciążeniu usługa odpowiada 429 z Retry-After: 5, co SDK szanuje.
Semafor ogranicza tylko zapytania w locie w ramach jednego procesu. Jeśli uruchomisz wiele workerów, podziel limit między nimi: przy pełnym kluczu cztery workery powinny używać semafora o wartości 2. Limit 300 na minutę jest dzielony przez wszystkie, więc kolejka ze stałą szybkością jest lepsza niż burst dla dużych zadań offline. Limit rozmiaru ciała żądania 8 MB rzadko jest problemem dla czatu, ale dotyczy każdego zapytania.
Tryb JSON i wywoływanie narzędzi
Oba działają przez normalne parametry. Dla trybu JSON ustaw response_format i poproś o JSON w promptcie.
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"])Wywoływanie narzędzi wymaga jednego dodatkowego kroku: wykonujesz funkcję sam i zwracasz wynik jako wiadomość 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)Wartość zwrócona dla kostki tutaj jest sztywno zakodowana dla zwięzłości. W prawdziwym kodzie wywołaj swoją funkcję z sides i wyślij jej wynik.
Dwa kolejne szczegóły dotyczące narzędzi. Użyj tool_choice, gdy musisz wymusić konkretną funkcję zamiast pozwalać modelowi na decyzję. I utrzymaj opisy narzędzi szczegółowe: model wybiera funkcję na podstawie samej nazwy i opisu, więc "Rzuć kostką z podaną liczbą ścian" działa lepiej niż "kostki". Jeśli odpowiedź zawiera wiele wywołań narzędzi, uruchom je wszystkie i dołącz jedną wiadomość tool na każde ID wywołania przed poproszeniem o ostateczną odpowiedź.
Błędy, ponawianie prób i historia rozmowy
SDK rzuca typowane wyjątki, co skraca obsługę błędów. Kod 429 rzuca openai.RateLimitError, awaria sieci rzuca openai.APIConnectionError, a inne niepowodzenia rzucają openai.APIStatusError. SDK już ponowiło połączenie, zanim zobaczysz pierwszy wyjątek, więc to, co trafi do Twojego kodu, to wywołanie, które nie powiodło się wielokrotnie.
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."}]))Kod odczytuje Retry-After, gdy usługa go wysyła, co dzieje się przy tymczasowym przeciążeniu (wartość to 5 sekund). Gdy nagłówek jest nieobecny, wycofuje się według własnego harmonogramu. Zauważ, że pętla nie przechwytuje każdego błędu: złe zapytanie nie poprawi się przy ponowieniu, więc pozwól mu się rozpropagować.
Historia rozmowy to drugi element stanu. API nie przechowuje go za ciebie, więc twój program jest właścicielem listy wiadomości. Prosta polityka, która dobrze działa: zachowaj wiadomość systemową, zachowaj ostatnie N tur, a gdy całkowity rozmiar przekroczy wybrany przez ciebie próg, poproś model o podsumowanie najstarszej części w jedną krótką wiadomość.
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] + recentPodsumowania również kosztują tokeny, ale zwracają się: rozmowa, która w przeciwnym razie ponownie wysyłałaby 20 000 tokenów przy każdej turze, spada do kilku tysięcy.
Odczyt salda i ID zapytania
Każda odpowiedź zawiera X-Request-Id i X-Balance-USD. SDK domyślnie ukrywa nagłówki, ale with_raw_response je ujawnia, nadal dając ci sparsowany obiekt.
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)Loguj ID zapytania przy każdym błędzie. Jeśli musisz skontaktować się z zespołem przez stronę wsparcie, to ID wskazuje bezpośrednio na wywołanie.
Nagłówek salda jest przydatny poza logowaniem. Zaplanowane zadanie może je odczytać po każdej partii i zatrzymać się, gdy kredyt spadnie poniżej ustalonego przez ciebie progu, lub wysłać ci wiadomość, abyś mógł doładować, zanim użytkownicy to zauważą. Kredyt nigdy nie wygasa, więc nie ma presji na jego wydanie. Doładowania to kwoty całkowite od $20 do $500, więc możesz doładować większymi krokami, jeśli wolisz.
Bez SDK: requests lub httpx
Jeśli wolisz unikać zależności, API jest na tyle proste, że wystarczy zwykły klient HTTP.
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"])Ustaw wystarczająco długi timeout dla długich completion. Model może wykorzystać tyle okna 100 000 tokenów, ile pozostawia prompt, więc nieograniczone zapytanie dla długiej fikcji może zająć trochę czasu.
Ta sama metoda działa przy strumieniowaniu. Dodaj "stream": true do ciała JSON, przekaż stream=True do requests.post i czytaj odpowiedź przez iter_lines(). Każda linia zdarzenia zaczyna się od data: i zawiera JSON, a strumień kończy się znacznikiem data: [DONE]. Parsowanie tego ręcznie to dobre ćwiczenie, choć w kodzie produkcyjnym SDK robi to z mniejszą liczbą przypadków brzegowych, takich jak częściowe linie i ponowne połączenia.
Zarządzanie budżetem w kodzie Pythona
Liczniki tokenów w resp.usage pozwalają obliczyć wydatki na każde wywołanie. Cena to $0,15 za 1M tokenów wejściowych i $0,50 za 1M tokenów wyjściowych.
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.25Druga linia sprawdza się ręcznie: 1M tokenów wejściowych kosztuje $0,15, a 200 000 tokenów wyjściowych kosztuje 0,2 x $0,50 = $0,10, co daje $0,25. Nieudane lub odrzucone zapytania nie są rozliczane, więc nie musisz ich odejmować. Doładowania zaczynają się od $20, a strona cennik wymienia bonusy przy $50, $100 i $200.
Pełną listę parametrów i kodów błędów znajdziesz w dokumentacji.
Utrzymuj bieżącą sumę w swoim zadaniu, aby pętla nie wydała więcej, niż zaplanowałeś. Zadanie wsadowe klasyfikujące 50 000 krótkich tekstów przy 400 tokenach wejściowych i 20 tokenach wyjściowych na tekst zużywa 20M tokenów wejściowych i 1M tokenów wyjściowych. Kosztuje to 20 x $0,15 + 1 x $0,50 = $3,50. Jeśli twój licznik pokazuje, że zadanie zużyło dwa razy więcej, coś pętluje.
