PL ▾

Python API OpenAI: Użyj SDK OpenAI z naszym modelem

Stylizowany kabel w kształcie węża podłączony do serwera z dymkami czatu, reprezentujący Pythona wywołującego API

Do kodu Python API OpenAI nie potrzebujesz specjalnej biblioteki. Oficjalny pakiet openai działa z tą usługą po ustawieniu innego base URL i klucza, a ID modelu to uncensored. Poniżej znajduje się pełny przewodnik z przykładowym kodem do skopiowania.

Zaktualizowano

Kluczowe punkty

  • Zainstaluj openai, a następnie przekaż base_url i api_key do klienta; nic innego w Twoim kodzie nie musi się zmienić.
  • Strumieniowanie, tryb JSON i wywoływanie narzędzi działają przez te same metody SDK.
  • Przechwyć i ponów próbę; limity to 300 zapytań na minutę i 8 równoległych zapytań dla pełnego klucza.
  • Koszt to $0,15 za 1M tokenów wejściowych i $0,50 za 1M tokenów wyjściowych, naliczany tylko za pomyślne zapytania.

Zainstaluj i wykonaj pierwsze wywołanie

Potrzebujesz Pythona 3.9 lub nowszego oraz oficjalnego SDK. Najpierw utwórz klucz API na stronie kluczy; nowe konta mogą jednym kliknięciem odebrać $0,50 kredytu próbnego bez podawania karty.

pip install openai
export API_KEY="your-key-here"

Teraz najmniejszy działający skrypt. Klient przyjmuje base URL i klucz; zapytanie używa ID modelu uncensored.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.aiapisource.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise writing assistant."},
        {"role": "user", "content": "Give me three opening lines for a mystery novel."},
    ],
    temperature=0.8,
)

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

To cała integracja. Usługa implementuje POST /v1/chat/completions i GET /v1/models, co pokrywa potrzeby większości skryptów. To model tekstowy, więc endpointy obrazu, audio i embeddingów są niedostępne.

Co to jest, a czym nie jest

SDK zostało stworzone przez OpenAI, ale endpoint tutaj nie należy do OpenAI. To hostowany model o otwartych wagach obsługiwany przez niezależnego dostawcę i dostrojony do odpowiadania bez odmów treści dla prawnego użytku dorosłych. Nie ma przekierowania do GPT ani modelu innego dostawcy. Dlatego zmieniasz base URL: rozmawiasz z innym serwerem, który akceptuje ten sam format zapytania.

Jeśli przenosisz istniejący projekt, wyszukaj w nim OpenAI( oraz na stałe wpisanych nazw modeli. To jedyne dwa miejsca wymagające edycji. Lista kontrolna wdrożenia produkcyjnego API GPT na tej stronie obejmuje nawyki stosujące się do każdego endpointu w formacie OpenAI, takie jak time outy i ponawianie.

Strumieniuj odpowiedź

W interfejsach czatowych chcesz otrzymywać tokeny w miarę ich generowania. Ustaw stream=True i iteruj. Poproś o użycie na końcu, jeśli chcesz uzyskać liczby z faktury:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem about a night train."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Sprawdzenie chunk.choices ma znaczenie: ostatni chunk może zawierać użycie i brak wyborów. Ponadto zapytanie strumieniowe zajmuje jeden slot równoległy do końca strumienia, więc zawsze odczytaj go do końca lub zamknij.

Tryb JSON

Gdy Twój kod musi sparsować odpowiedź, włącz tryb JSON i opisz klucze w promptcie:

import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "user", "content": "Return JSON with keys name (string) and traits (list of 3 strings) for a fictional ship captain."}
    ],
)
character = json.loads(resp.choices[0].message.content)
print(character["name"], character["traits"])

Poprawny JSON jest prawdopodobnym wynikiem, ale nie obietnicą dokładnego schematu, więc sprawdź klucze i ponów próbę raz w przypadku błędu.

Wywoływanie funkcji

Opisz funkcje w tools, uruchom to, o co poprosi model, i wyślij wynik z powrotem z role: "tool":

import json

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 20-sided die for my character."}]
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 = {"value": 14, "sides": args["sides"]}  # replace with real logic
        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)

Możesz przekazać tool_choice, aby wymusić funkcję. Argumenty są ciągiem JSON, więc zawsze uruchamiaj je przez json.loads i zwaliduj przed użyciem.

Błędy, ponawianie i async

SDK powtarza niektóre niepowodzenia automatycznie, a liczbę możesz ustawić za pomocą max_retries. W przypadku limitów zapytań przechwyć wyjątek i poczekaj. API zwraca HTTP 429 z kodem rate_limited przy przekroczeniu limitu na minutę, z concurrency przy zbyt dużej liczbie równoległych zapytań oraz z nagłówkiem Retry-After: 5 przy tymczasowym przeciążeniu.

import time
from openai import RateLimitError

def ask(prompt, tries=4):
    for attempt in range(tries):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError:
            time.sleep(5 * (attempt + 1))
    raise RuntimeError("Still rate limited after retries")

Do partii użyj klienta async i ogranicz równoległość poniżej limitu. Pełny klucz pozwala na 8 równoległych zapytań i 300 na minutę; klucz próbny na 2 i 60.

import asyncio, os
from openai import AsyncOpenAI

aclient = AsyncOpenAI(base_url="https://api.aiapisource.com/v1", api_key=os.environ["API_KEY"])
sem = asyncio.Semaphore(6)

async def one(prompt):
    async with sem:
        r = await aclient.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Write a tagline for product number {i}." for i in range(20)]
    results = await asyncio.gather(*(one(p) for p in prompts))
    print(len(results), "done")

asyncio.run(main())

Użycie 6 z 8 slotów zostawia miejsce na inny ruch dla tego samego klucza.

Kontynuuj rozmowę

API jest bezstanowe. Nie pamięta niczego między wywołaniami, więc czat to po prostu lista wiadomości wysyłanych za każdym razem. Dodaj odpowiedź do listy i wyślij całą listę ponownie:

history = [{"role": "system", "content": "You are a patient writing coach."}]

def chat(user_text):
    history.append({"role": "user", "content": user_text})
    r = client.chat.completions.create(model="uncensored", messages=history)
    reply = r.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(chat("Give me a prompt for a short story."))
print(chat("Make it darker and set it in a harbour town."))

Każde wywołanie wysyła więcej tokenów niż poprzednie, a tokeny wejściowe są rozliczane przy każdym wywołaniu. Gdy lista jest długa, usuń najstarsze tury lub zastąp je krótkim podsumowaniem. Okno kontekstu wynosi 100 000 tokenów dla prompta plus completion, co jest dużo, ale długa historia sprawia, że każde zapytanie jest droższe i wolniejsze w uruchomieniu.

Ustawienia próbkowania są przekazywane: temperature, top_p, stop, seed oraz kary za częstotliwość i obecność. Ustaw seed i niską temperaturę, gdy chcesz powtarzalnych testów.

Oszacuj koszt przed dużym uruchomieniem

Rozliczenie jest na tokeny z przedpłaconego kredytu: $0,15 za 1M tokenów wejściowych i $0,50 za 1M tokenów wyjściowych. Nieudane lub odrzucone zapytania nie są rozliczane, a kredyt nigdy nie wygasa. Weź partię 10 000 zapytań z 1 500 tokenami wejściowymi i 400 wyjściowymi każde. Wejście to 15 000 000 tokenów, czyli 15 x $0,15 = $2,25. Wyjście to 4 000 000 tokenów, czyli 4 x $0,50 = $2,00. Partia kosztuje $4,25.

Nagłówki odpowiedzi zawierają X-Balance-USD, więc możesz odczytać pozostałe saldo w kodzie przez client.chat.completions.with_raw_response.create(...). Doładowania to dowolna kwota całkowita od $20 do $500, z +5% od $50, +10% od $100 i +15% od $200. Strona cenowa wymienia opcje płatności, a szybki start wymienia każdy obsługiwany parametr, w tym stop, seed i kary.

Pytania i odpowiedzi

Czy mogę użyć oficjalnego pakietu Pythona OpenAI z tym API?

Tak. Zainstaluj openai, ustaw base_url na endpoint usługi, a api_key na swój klucz, a następnie wywołaj chat.completions.create z modelem uncensored.

Czy potrzebuję innej biblioteki do strumieniowania lub narzędzi?

Nie. Strumieniowanie, tryb JSON i wywoływanie narzędzi działają przez te same metody SDK, ze standardowymi parametrami.

Czy to model OpenAI?

Nie. To model o otwartych wagach obsługiwany przez niezależnego dostawcę. Format zapytania jest taki sam, dlatego SDK działa.

Czy moje prompty są używane do trenowania modelu?

Nie. Prompty wysłane przez API nie są używane do trenowania.

Twój klucz jest o jeden formularz stąd

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

Pobierz klucz API