PL ▾

openaiapiproxy.comProxy API OpenAI w Pythonie: konfiguracja i przykłady

Proxy API OpenAI w Pythonie: konfiguracja i przykłady

W projekcie proxy api openai python zachowujesz oficjalny pakiet openai i zmieniasz dwa argumenty konstruktora: base_url i api_key. Reszta tej strony omawia strumieniowanie, asynchroniczność, narzędzia, ponawianie prób i zarządzanie budżetem.

Zaktualizowano

Szklany terminal z wstęgą światła płynącą ku sześcianowi, ilustrujący kod Pythona wywołujący proxy API

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] + recent

Podsumowania 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.25

Druga 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.

Pytania i odpowiedzi

Czy potrzebuję specjalnego pakietu Python?

Nie. Oficjalny pakiet openai wystarczy. Ustaw base_url i klucz API w kliencie i użyj nazwy modelu uncensored.

Czy klient asynchroniczny działa?

Tak. AsyncOpenAI przyjmuje te same argumenty. Ogranicz współbieżność do 8 zapytań dla pełnego klucza lub 2 dla klucza próbnego.

Jak zobaczyć pozostały kredyt z kodu?

Przeczytaj nagłówek odpowiedzi X-Balance-USD. W pakiecie openai użyj with_raw_response, a następnie przeczytaj raw.headers.

Co się dzieje przy błędzie 429?

Kod błędu rate_limited lub concurrency informuje, który limit przekroczyłeś. SDK domyślnie ponawia zapytania, a nagłówek Retry-After jest wysyłany przy tymczasowym przeciążeniu.

Twój klucz jest o jeden formularz stąd

Utwórz konto, skopiuj klucz, zmień bazowy URL. To cała konfiguracja.

Pobierz klucz API