API OpenAI dla programistów: Użyj kompatybilnego endpointu

Krótka wersja

Większość przewodników na temat API OpenAI dla programistów zakłada jednego dostawcę i jeden rachunek. Format sieciowy to jednak tylko JSON przez HTTPS, a wiele kodu klienckiego, frameworków i narzędzi może rozmawiać z każdym serwerem, który go implementuje. Ta strona hostuje jeden taki serwer. Zachowujesz swoje SDK, zmieniasz Base URL, zamieniasz klucz na klucz z tej strony i ustawiasz model na uncensored.

To cała migracja dla typowej aplikacji. Oto lista kontrolna, a reszta strony wypełnia każdy krok.

1. Załóż konto i odbierz kredyt próbny na stronie klucza API.
2. Ustaw Base URL na https://api.openaigatewayapi.com/v1.
3. Wyślij klucz jako Authorization: Bearer <key>. SDK robią to za Ciebie, gdy przekażesz api_key.
4. Użyj uncensored jako ID modelu w każdym żądaniu.
5. Obsłuż HTTP 429 krótkim ponowieniem, jak pokazano w pobliżu końca.

Istnieją dwa endpointy: POST /v1/chat/completions i GET /v1/models. Usługa jest tylko tekstowa. Nie ma generowania obrazów ani audio, nie ma embeddingów ani fine-tuning, więc jeśli Twoja aplikacja ich używa, potrzebują innego dostawcy.

Sprawdź połączenie z curl

Przed modyfikacją aplikacji upewnij się, że klucz działa. Endpoint modeli to najtańszy test, ponieważ nie generuje tokenów.

Copyexport API_KEY="paste-your-key-here"

curl https://api.openaigatewayapi.com/v1/models \
  -H "Authorization: Bearer $API_KEY" | grep -o uncensored

Grep wypisuje ID modelu uncensored, jeśli lista go zawiera; pomiń grep, aby zobaczyć pełną listę JSON. Jeśli otrzymasz 401, klucz jest błędny lub brakuje prefiksu Bearer. Teraz wyślij prawdziwe żądanie:

Copycurl https://api.openaigatewayapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ],
    "temperature": 0.4
  }'

Odpowiedź zawiera obiekty choices i usage. Zawiera również nagłówki warte zalogowania: X-Request-Id do pytań wsparcia, X-Balance-USD dla Twojego pozostałego kredytu oraz dwa nagłówki X-RateLimit-Limit-* pokazujące limity zapytań i pojemności równoległych.

Python z oficjalnym pakietem openai

W Pythonie modyfikujesz tylko konstruktor klienta. Wszystko po nim to kod, który już masz.

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short, accurate release notes."},
        {"role": "user", "content": "Summarise: added retry logic, fixed timeout bug."},
    ],
    temperature=0.5,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

W rzeczywistym kodzie odczytaj klucz ze zmiennej środowiskowej. W przykładzie jest on zmienną stałą tylko dla skrócenia fragmentu. max_tokens jest opcjonalne; jeśli go nie podasz, uzupełnienie może wykorzystać wszystko, co zostało z okna 100 000 tokenów (prompt plus uzupełnienie łącznie). Ustawienie go to tani sposób na ograniczenie kosztów przy niekontrolowanej generacji.

Strumieniowanie

Strumieniowanie używa zdarzeń wysłanych przez serwer i tej samej flagi stream=True, którą znasz. Liczby użycia pojawiają się na końcu strumienia, więc ostatni fragment może mieć pustą listę choices.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List five edge cases for a date parser."}],
    stream=True,
)

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):
        print("\ntokens:", chunk.usage.total_tokens)

Jeden szczegół ma znaczenie dla planowania pojemności. Zapytanie strumieniowe zajmuje swój slot równoległości do zakończenia strumienia, a nie do wysłania pierwszego tokena. Jeśli klient porzuci strumień bez jego zamknięcia, ten slot pozostaje zajęty dłużej, niż się spodziewasz.

Przykład Node.js

SDK dla Node.js przyjmuje te same dwa ustawienia pod innymi nazwami.

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.openaigatewayapi.com/v1",
  apiKey: process.env.GATEWAY_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "user", content: "Write a regex that matches ISO 8601 dates, and explain it." },
  ],
  temperature: 0.3,
});

console.log(completion.choices[0].message.content);

Jeśli używasz frameworka z własną integracją OpenAI, wyszukaj pole base URL, API base lub endpoint w jego ustawieniach. Wklejenie tego samego URL tam zwykle wystarczy. Frontendy czatu, frameworki agentów i wtyczki edytorów zazwyczaj podążają tym wzorcem. Parametry próbkowania takie jak temperature, top_p, stop, seed oraz kary za częstotliwość i obecność są przekazywane do modelu.

Wywoływanie narzędzi i tryb JSON

Dwie funkcje decydują, czy model pasuje do prawdziwej aplikacji: wywoływanie Twoich funkcji i zwracanie danych, które można sparsować. Obie są wspierane.

Wywoływanie funkcji

Ogłaszasz narzędzia z tools, opcjonalnie wymuszasz wybór z tool_choice i wysyłasz wyniki z powrotem jako wiadomości z role: "tool". Odpowiedzi strumieniowe dostarczają tool_calls w kawałkach, tak jak w standardowym formacie.

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
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]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup here
    messages.append(msg)
    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)

Zawsze waliduj argumenty przed ich użyciem. Model generuje JSON pasujący do Twojego schematu w większości przypadków, nie zawsze, więc traktuj call.function.arguments jak każde inne niezaufane wejście.

Tryb JSON

Do zadań ekstrakcji i klasyfikacji poproś o obiekt JSON i wspomnij o tym w promptcie. Wzmianka o JSON w instrukcjach daje lepsze wyniki niż poleganie tylko na flagie.

Copyfrom openai import OpenAI
import json

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"sentiment\": string, \"topics\": [string]}."},
        {"role": "user", "content": "The docs are clear but the rate limits caught me off guard."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data)

Limity, błędy i ponawianie

Pełny klucz pozwala na 8 żądań w locie i 300 żądań na minutę. Klucz próbny pozwala na 2 w locie i 60 na minutę. Maksymalny rozmiar ciała żądania to 8 MB. Przekroczenie limitu daje HTTP 429, a kod błędu mówi, który limit został przekroczony.

Kod błędu	Znaczenie	Co zrobić
rate_limited	Zbyt wiele zapytań na minutę	Zwolnij producenta lub rozłóż pracę na minutę
concurrency	Zbyt wiele zapytań naraz	Obniż liczbę workerów do 8 lub mniej, lub 2 dla klucza próbnego
429 z Retry-After: 5	Tymczasowe przeciążenie	Poczekaj podaną liczbę sekund i spróbuj ponownie

SDK-y już ponawiają niektóre niepowodzenia. Dodaj własną obsługę błędu 429, aby nagły wzrost ruchu nie spowodował awarii zadania wsadowego:

Copyimport time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
    max_retries=0,
)

def ask(prompt, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            wait = float(e.response.headers.get("retry-after", 2 ** i))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

Zapytania nieudane lub odrzucone nie są rozliczane, więc pętla ponownych prób nie podwaja Twojego rachunku. Semafor wielkości Twojego limitu współbieżności to najczystszy sposób na utrzymanie się poniżej progu w kodzie asynchronicznym.

Przeniesienie istniejącej aplikacji

Jeśli masz działającą aplikację, nie hardkoduj nowych wartości. Umieść Base URL, klucz i nazwę modelu w zmiennych środowiskowych, abyś mógł przełączać się między środowiskami bez wdrażania. Pozwoli to też uruchomić ten sam zestaw testów przeciwko dwóm backendom i porównać wyjścia obok siebie.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.openaigatewayapi.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

def complete(messages, **kw):
    return client.chat.completions.create(model=MODEL, messages=messages, **kw)

Następnie przejdź przez krótką procedurę migracji:

1. Uruchom swój istniejący zestaw promptów przeciwko nowemu endpointowi i przeczytaj wyjścia samodzielnie. Automatyczne sprawdzenia wykrywają naruszenia formatu, nie ton.
2. Sprawdź, czy kod parsujący JSON nadal przechodzi z response_format ustawionym i zachowaj fallback, który usuwa przypadkowy tekst wokół obiektu.
3. Zmierz prawdziwe liczniki tokenów z usage, ponieważ inny model tokenizuje tekst inaczej i Twoje stare szacunki mogą być błędne.
4. Ustaw pulę workerów na 8 lub mniej, aby limit concurrency nigdy nie był pierwszą rzeczą, która zawiedzie pod obciążeniem.
5. Wdróż na mały udział ruchu, obserwuj częstość 429 i dzienniki błędów, a następnie zwiększ zakres.

Zespoły często zapominają o promptzie systemowym w tym procesie. Prompty napisane tak, aby nakłonić model skłonny do odmów, zawierają zwykle dygresje, które są tu niepotrzebne i mogą zaciemniać wyjście. Przeczytaj je ponownie i usuń to, co już nie robi nic.

Co wiedzieć przed przełączeniem

Kompatybilność obejmuje format zapytania i odpowiedzi. Nie czyni to jednak tego oficjalnym API żadnego twórcy modelu. Usługa uruchamia jeden model o otwartych wagach, hostowany przez niezależnego dostawcę i dostrojony do odpowiadania bez odmów treści dla prawnego użytku dorosłych. Nie jest to router między dostawcami, więc nie znajdziesz za nim menu innych modeli. Treści seksualne z udziałem nieletnich są niedozwolone, a ten limit nie ulega zmianie.

Zaplanuj uwzględniając trzy praktyczne różnice w stosunku do dużej platformy wielomodelowej:

• Jeden model. ID to uncensored. Jeśli Twój kod przełącza modele według zadania, skróć to do jednej wartości.
• Tylko tekst. Usuń dowolne wywołania obrazu, audio lub embeddingów z ścieżki prowadzącej do tego endpointu.
• Zachowanie promptów się różni. Inny model czyta instrukcje inaczej, więc uruchom ponownie swoje prompty i testy po przełączeniu. Zaostrz prompty systemowe, jeśli wyjście odbiega.

Prompty nie są używane do trenowania. Pełną listę parametrów znajdziesz w dokumentacji API. Jeśli szacujesz wydatki, strona z cenami podaje stawki za token: $0,15 za 1M tokenów wejściowych i $0,50 za 1M tokenów wyjściowych, rozliczane z przedpłaconego kredytu bez subskrypcji. Doładowania wynoszą od $20 do $500, a kredyt nie wygasa. Jeśli rozważasz warstwę proxy przed kilkoma usługami, strona o bramach LLM omawia, kiedy ten dodatkowy element się opłaca.

Więcej przewodników

• OpenAI Gateway API Wyjaśnione Prostym Językiem
• Ceny OpenAI Gateway API: Przykładowe Rzeczywiste Koszty
• Brama LLM: Analiza Kosztów vs. Złożoności