PL ▾
Pobierz klucz API

Workflow LLM API w Pythonie: konfiguracja krok po kroku

Wskaż OpenAI SDK na nowy base URL, użyj ID modelu uncensored i dodawaj retry, równoległe uruchomienia i wywołania narzędzi warstwa po warstwie.

Zaktualizowano

Potok świecących bloków z kostkami danych rozgałęziającymi się na równoległe pasy, reprezentujący workflow LLM w Pythonie

Kluczowe punkty

  • Zainstaluj openai, ustaw base_url na https://api.veo3apis.com/v1 i użyj modelu uncensored.
  • Obsłuż 429, czekając na Retry-After; nieudane zapytania nie są rozliczane.
  • Dostosuj rozmiar puli wątków do klucza: 8 wątków dla pełnego klucza, 2 dla klucza próbnego.
  • Odczytaj X-Balance-USD z nagłówków odpowiedzi, aby śledzić wydatki na każde uruchomienie.

Krótka wersja

Aby zbudować skrypt workflow LLM API w Pythonie, zainstaluj oficjalne OpenAI SDK, ustaw base URL na https://api.veo3apis.com/v1, użyj swojego klucza jako klucza API i wywołaj model uncensored. Nic się nie zmienia. Usługa jest kompatybilna z OpenAI, więc każdy znany Ci wzorzec z SDK działa: zwykłe wywołania czatu, strumieniowanie, tryb JSON i wywoływanie narzędzi.

Ten artykuł buduje mały workflow warstwa po warstwie. Zacznij od jednego wywołania, a następnie dodaj konfigurację ze zmiennych środowiskowych, opakowanie retry, równoległy uruchamiacz, wywołanie narzędzia i śledzenie salda. Każda warstwa jest krótka, a możesz zatrzymać się na dowolnej, która spełnia Twoje potrzeby.

Model to jeden model o otwartych wagach uruchamiany przez niezależnego dostawcę. Nie jest to oficjalne API żadnego dużego dostawcy i nie jest to router, więc zapamiętać trzeba tylko jedno ID modelu. Obsługuje tylko tekst. Nie ma generowania obrazów, audio ani wideo, nie ma embeddingów ani fine-tuningu.

Zainstaluj SDK i wykonaj pierwsze wywołanie

Potrzebujesz Pythona 3.9 lub nowszego. Zainstaluj SDK:

pip install openai

Utwórz klucz na stronie klucza API po zalogowaniu się przez Google lub e-mail i hasło. Na stronie znajduje się też jedno kliknięcie, aby odebrać $0.50 kredytu próbnego, ważny przez 7 dni, jeden na osobę, bez karty. Następnie wykonaj najmniejsze możliwe wywołanie:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "List three uses for a hosted text API."},
    ],
)

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

Jeśli wydrukuje tekst i obiekt użycia, uwierzytelnienie, routing i ID modelu są poprawne. SDK wysyła Twój klucz jako Authorization: Bearer, a żądanie trafia do POST /v1/chat/completions. Możesz sprawdzić, które ID modeli widzi Twój klucz, używając client.models.list(), co wywołuje GET /v1/models.

Wersja raw curl jest przydatna, gdy debugujesz z serwera bez Pythona:

curl https://api.veo3apis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello."}]}'

Trzymaj konfigurację w jednym kliencie

Wpisanie klucza na sztywno w skrypcie to najszybszy sposób na wyciek go do repozytorium. Odczytaj obie wartości ze środowiska i utwórz klienta w jednym miejscu, aby każdy krok w przepływie pracy go udostępniał.

import os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.veo3apis.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
    max_retries=0,
    timeout=120,
)

MODEL = "uncensored"


def ask(system: str, user: str, **kwargs) -> str:
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        **kwargs,
    )
    return resp.choices[0].message.content

Dwa wybory są celowe. max_retries=0 wyłącza wbudowane ponowienia SDK, więc logika ponawiania w następnej sekcji jest jedyną, co ułatwia rozumienie zachowania. Limit 120 sekund daje miejsce na długie uzupełnienia; okno kontekstu ma 100 000 tokenów dla prompt plus uzupełnienie, a duża odpowiedź wymaga czasu na strumieniowanie. Parametry próbkowania takie jak temperature, top_p, stop, seed i kary przechodzą przez **kwargs jak zwykle.

Ponawiaj właściwe błędy

Każdy prawdziwy przepływ pracy prędzej czy później napotka limity żądań. Pełny klucz pozwala na 300 żądań na minutę i 8 naraz. Klucz próbny pozwala na 60 na minutę i 2 naraz. Przekroczenie któregokolwiek z nich powoduje, że API zwraca HTTP 429. Kod błędu informuje Cię, który limit przekroczyłeś: rate_limited dla żądań na minutę, concurrency dla zbyt wielu naraz. Podczas tymczasowego przeciążenia API wysyła również 429 z nagłówkiem Retry-After: 5.

Wszystkie trzy przypadki mają takie samo rozwiązanie: poczekaj, a następnie spróbuj ponownie. To opakowanie respektuje nagłówek i stosuje backoff, gdy go brakuje.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from openai import RateLimitError, APIConnectionError, APIStatusError


def call_with_retry(messages, tries=5, **kwargs):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(
                model="uncensored", messages=messages, **kwargs
            )
        except RateLimitError as err:
            wait = err.response.headers.get("Retry-After")
            time.sleep(int(wait) if wait else delay)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
        except APIStatusError as err:
            if err.status_code < 500:
                raise
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("request failed after retries")

Ponawiaj tylko błędy, które mogą się zmienić. 400 oznacza, że Twoje żądanie jest niepoprawne, a jego ponowne wysłanie zakończy się tym samym błędem, więc opakowanie ponownie zgłasza każdy błąd klienta z wyjątkiem 429. Nieudane lub odrzucone żądania nie są rozliczane, więc ponawianie nie kosztuje nic dodatkowego.

Uruchamiaj wiele wejść równolegle

W przypadku pętli po wielu wejściach wystarczająca jest pula wątków. Klient SDK jest bezpieczny do udostępniania między wątkami. Dopasuj rozmiar puli do swojego klucza: 8 workerów dla pełnego klucza, 2 dla klucza próbnego.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError


def summarize(text: str) -> str:
    for _ in range(5):
        try:
            resp = client.chat.completions.create(
                model="uncensored",
                messages=[
                    {"role": "system", "content": "Summarize the text in two sentences."},
                    {"role": "user", "content": text},
                ],
                max_tokens=150,
            )
            return resp.choices[0].message.content.strip()
        except RateLimitError as err:
            time.sleep(int(err.response.headers.get("Retry-After", "5")))
    return ""


documents = ["First long text...", "Second long text...", "Third long text..."]

with ThreadPoolExecutor(max_workers=8) as pool:
    summaries = list(pool.map(summarize, documents))

for s in summaries:
    print(s)

Rozmiar puli nie jest tym samym co częstotliwość żądań. Ośmiu workerów kończących każde wywołanie w pół sekundy wykonałoby 960 żądań na minutę, znacznie ponad 300. Jeśli Twoje wywołania są szybkie, dodaj małe opóźnienie lub ogranicznik wiadra żetonów, aby pozostać poniżej limitu na minutę. Jeśli Twoje wywołania są wolne, konkurencja jest limitem, który napotkasz jako pierwszy. Żądania strumieniowe zajmują swoje miejsce do zakończenia strumienia.

Dane strukturalne i wywoływanie narzędzi

Dwie funkcje zamieniają wywołanie czatu w krok przepływu pracy, na którym mogą polegać inne komponenty. Tryb JSON gwarantuje wynik, który da się sparsować. Wywoływanie funkcji pozwala modelowi poprosić Twój kod o wykonanie zadania, a następnie wykorzystać odpowiedź.

Tryb JSON

Ustaw response_format na obiekt JSON i opisz klucze w prompt.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "A short post about nightly backups."},
    ],
)
post = json.loads(resp.choices[0].message.content)
print(post["title"], post["tags"])

Wywoływanie funkcji

Zadeklaruj narzędzia z tools, opcjonalnie wymuś wybór z tool_choice, uruchom funkcję samodzielnie i wyślij wynik z powrotem jako wiadomość z role: "tool".

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

tools = [{
    "type": "function",
    "function": {
        "name": "word_count",
        "description": "Count the words in a piece of text.",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in 'the quick brown fox'?"}]
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 = {"words": len(args["text"].split())}
        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)

Zawsze sprawdzaj, czy tool_calls jest obecny przed jego odczytaniem. Model może odpowiedzieć bezpośrednio, a Twój kod powinien obsłużyć oba wyniki.

Łącz kroki w potok

Prawdziwe przepływy pracy rzadko kończą się na jednym wywołaniu. Typowy kształt to szkic, recenzja, poprawka: pierwsze wywołanie generuje coś, drugie krytykuje to na podstawie listy kontrolnej, a trzecie stosuje krytykę. Każdy krok to osobne zapytanie z własną wiadomością systemową, co sprawia, że instrukcje są krótkie, a błędy łatwe do zlokalizowania.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

def step(system: str, user: str, temperature: float = 0.7) -> str:
    resp = client.chat.completions.create(
        model="uncensored",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        temperature=temperature,
        max_tokens=800,
    )
    return resp.choices[0].message.content.strip()


topic = "a changelog entry for a new export feature"

draft = step("Write the requested text in under 120 words.", topic)
review = step(
    "List at most three concrete problems with this text: vague wording, missing detail, wrong tone.",
    draft,
    temperature=0.2,
)
final = step(
    "Rewrite the text so it fixes every listed problem. Reply with the text only.",
    "TEXT:\n" + draft + "\n\nPROBLEMS:\n" + review,
)
print(final)

Zwróć uwagę na niższą temperaturę w kroku recenzji. Krytyka powinna być spójna od uruchomienia do uruchomienia, podczas gdy generowanie szkicu czerpie korzyści z pewnego zróżnicowania. Jeśli uruchamiasz potok dla wielu wejść, umieść całą funkcję trzyczęściową wewnątrz wątku puli z poprzedniego rozdziału, aby każdy wątek obsługiwał jeden element od początku do końca i szczyt 8 zapytań był respektowany.

Przechowuj wyniki pośrednie. Gdy ostateczny tekst jest błędny, szkic i recenzja wskazują, który krok się nie udał, a Ty możesz naprawić jedną wiadomość systemową zamiast przepisywania całego potoku. Zapisywanie każdego kroku do pliku JSON-lines z wejściem, trzema wynikami i identyfikatorami zapytań ułatwia to i daje punkt wznowienia, jeśli proces zatrzyma się w połowie.

Śledź saldo i ID zapytań

Każda odpowiedź zawiera nagłówki warte zalogowania: X-Request-Id identyfikuje wywołanie, jeśli skontaktujesz się z pomocą techniczną, X-Balance-USD pokazuje, ile zostało z Twojego kredytu, a dwa nagłówki X-RateLimit-Limit raportują limity zapytań i równoległości dla Twojego klucza. SDK domyślnie ukrywa nagłówki; użyj opakowania raw-response, aby je odczytać.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Reply with the single word ready."}],
    max_tokens=10,
)

print("request id:", raw.headers.get("X-Request-Id"))
print("balance usd:", raw.headers.get("X-Balance-USD"))
print("req limit:", raw.headers.get("X-RateLimit-Limit-Requests"))
print("concurrency limit:", raw.headers.get("X-RateLimit-Limit-Concurrency"))

resp = raw.parse()
print(resp.choices[0].message.content)

Ceny to $0.15 za milion tokenów wejściowych i $0.50 za milion tokenów wyjściowych, więc wywołanie z 1 000 tokenami wejściowymi i 500 tokenami wyjściowymi kosztuje $0.00015 + $0.00025 = $0.0004. Przepływ pracy, który wykonuje 5 000 takich wywołań, wydaje $2.00. Wypisz saldo na początku i końcu uruchomienia, a będziesz wiedział, ile kosztuje każda partia bez dodatkowych narzędzi. Aby uzyskać informacje o stawkach i bonusach za doładowanie, zobacz stronę cen; dla każdego obsługiwanego parametru przeczytaj dokumentację API.

Jeszcze jedna przydatna praktyka: trzymaj prompty poza swoimi logami, chyba że ich potrzebujesz. Prompty wysłane do tego API nie są używane do trenowania, ale Twoje własne pliki logów są Twoją odpowiedzialnością.

Rozwiązywanie problemów z nową konfiguracją

Większość problemów przy pierwszym uruchomieniu wynika z krótkiej listy przyczyn.

  • Wywołanie się zawiesza lub zwraca błąd podczas łączenia. Sprawdź adres URL bazowy. Musi kończyć się na /v1, a SDK dołącza /chat/completions samodzielnie. Podwójna ścieżka to typowy błąd.
  • Błąd uwierzytelnienia. Klucz jest nieobecny, ucięty lub ma przypadkową spację lub znak nowej linii po skopiowaniu i wklejeniu. Wypisz jego długość, a nie sam klucz, i porównaj go z tym, co pokazuje strona klucza.
  • Nie znaleziono modelu. ID modelu to uncensored, zapisane małymi literami. Wywołaj endpoint modeli, aby zobaczyć dokładnie, czego może użyć Twój klucz.
  • Stałe 429 w małym skrypcie. Możesz być na kluczu próbnym, który pozwala na 2 równoległe żądania i 60 na minutę. Zmniejsz pulę do 2 workerów lub doładuj, aby uzyskać pełny klucz.
  • Odpowiedzi ucięte. Niska wartość max_tokens powoduje przedwczesne zakończenie odpowiedzi. Zwiększ ją lub usuń, aby generowanie odpowiedzi wykorzystało resztę okna kontekstowego.
  • Zbyt duże zapytanie. Limit treści to 8 MB, a okno kontekstowe wynosi 100 000 tokenów dla promptu i wygenerowanej odpowiedzi łącznie. Podziel duże wejścia na części i przetwarzaj je jako osobne wywołania.

Gdy coś wygląda na błędne po stronie usługi, wyślij wartość z X-Request-Id do kontaktu na stronie. Identyfikator zapytania pozwala operatorowi znaleźć Twoje dokładne wywołanie, co jest znacznie bardziej przydatne niż opis tego, co widziałeś.

01

Pytania i odpowiedzi

Czy potrzebuję specjalnego SDK?

Nie. Oficjalne SDK OpenAI dla Pythona zadziała, gdy ustawisz adres URL bazowy i swój klucz.

Które ID modelu powinienem użyć?

Użyj uncensored. Możesz wypisać dostępne identyfikatory za pomocą GET /v1/models.

Ile zapytań może być uruchomionych równolegle?

Pełny klucz pozwala na 8 równoległych żądań i 300 na minutę. Klucz próbny pozwala na 2 i 60.

Czy strumieniowanie działa w Python SDK?

Tak. Przekaż stream=True i iteruj po fragmentach. Zużycie jest raportowane na końcu strumienia.

Twój klucz dzieli od Ciebie jeden formularz

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

Pobierz klucz APIPrzeczytaj dokumentację