PL ▾
Pobierz klucz API

Jak zaimplementować LLM w Pythonie za pomocą hostowanego API

W większości projektów implementacja LLM w Pythonie sprowadza się do wywoływania hostowanego modelu przez HTTP, a nie jego trenowania lub serwowania. Przy API kompatybilnym z OpenAI zajmuje to około dziesięciu linii, a ten sam kod rozrasta się o strumieniowanie, wyjście JSON i wywoływanie funkcji.

Zaktualizowano

Terminal wysyłający wiązkę do serwera w chmurze i odbierający kostki danych, ilustrujący wywołanie Pythona do hostowanego LLM

Kluczowe punkty

  • Zainstaluj pakiet openai, ustaw bazowy URL i klucz, a następnie użyj ID modelu uncensored.
  • Strumieniowanie, tryb JSON i wywoływanie funkcji są obsługiwane i używają standardowych argumentów SDK.
  • Przechowuj historię czatu na liście i pilnuj okna 100 000 tokenów.
  • Obsłuż HTTP 429 krótkim ponowieniem; nieudane lub odrzucone zapytania nie są rozliczane.

API hostowane lub własny model

Istnieją dwa sposoby wdrożenia modelu językowego do programu w Pythonie. Możesz uruchomić wagi samodzielnie, co oznacza GPU, stos serwujący, wybory kwantyzacji i długie oczekiwanie na pobrania. Albo możesz wysyłać zapytania do modelu, który już uruchomiła inna osoba. Pierwsza droga ma sens w badaniach, ścisłej izolacji danych lub bardzo dużym, stałym ruchu. Druga pasuje do prawie wszystkiego innego: skryptu, bota, funkcji produktu, prototypu, który ma działać do obiadu.

Ten przewodnik podąża drugą ścieżką. Usługa to hostowane, kompatybilne z OpenAI API tekstowe z jednym modelem o otwartych wagach, prowadzone przez niezależnego dostawcę i dostrojone do odpowiadania bez odmów treści w ramach zgodnego z prawem użytku przez dorosłych. Nie jest to oficjalne API żadnego dostawcy modeli. Ponieważ korzysta z formatu żądań OpenAI, działa standardowy pakiet openai, a także czyste requests, jeśli wolisz brak zależności.

Krok 1: zainstaluj i wykonaj pierwsze wywołanie

Zainstaluj SDK i przechowuj swój klucz w zmiennej środowiskowej, aby nigdy nie trafił do kodu źródłowego.

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

Następnie utwórz klienta z base_url usługi. Jedynymi rzeczami, które zmieniasz w porównaniu do dowolnego innego ustawienia w stylu OpenAI, są URL, klucz i nazwa modelu.

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain list comprehensions in two sentences."},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage)

To kompletny działający program. Endpoint za nim to POST /v1/chat/completions, uwierzytelniany przez Authorization: Bearer <key>, a GET /v1/models wylicza ID modelu. Możesz uzyskać klucz i mały kredyt próbny na stronie klucza.

Krok 2: strumieniuj odpowiedź

Oczekiwanie kilku sekund na pełną odpowiedź jest wolne w terminalu lub na stronie internetowej. Ustaw stream=True i wypisuj tokeny, gdy przychodzą w ramach zdarzeń wysyłanych przez serwer.

# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
    stream=True,
)

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

Liczby zużycia pojawiają się na końcu strumienia, więc ostatni fragment może nie zawierać pola choices. Dlatego pętla najpierw sprawdza chunk.choices. Jedna rzecz, o której warto pamiętać: zapytanie strumieniowe zajmuje swój slot równoległości aż do końca strumienia, więc zawsze odczytuj go do końca lub zamknij.

Krok 3: prowadź rozmowę

Model nie ma pamięci między wywołaniami. Czat to po prostu rosnąca lista wiadomości, które wysyłasz ponownie za każdym razem. Wystarczy mała klasa:

# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
    def __init__(self, system):
        self.messages = [{"role": "system", "content": system}]

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

bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))

Okno kontekstu ma 100 000 tokenów, dzielonych przez prompt i wygenerowany tekst. To dużo miejsca, ale długi czat rośnie z każdą turą, a płacisz za całą historię przy każdym zapytaniu. Gdy staje się duża, usuń najstarsze tury lub zastąp je krótkim streszczeniem które każesz napisać modelowi.

Krok 4: uzyskaj dane strukturalne

Programy chcą danych, nie akapitów. Tryb JSON sprawia, że odpowiedź jest poprawnym JSON. Powiedz w prompcie, jakich kluczy oczekujesz.

# client from step 1: base_url https://api.fluxapikey.com/v1
import json

r = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
        {"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
    ],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])

Poprawny JSON nie gwarantuje Twoich kluczy. Sprawdź je w kodzie i ponów próbę raz, jeśli któregoś brakuje.

Krok 5: pozwól modelowi wywołać Twoje funkcje

Wywoływanie narzędzi pozwala modelowi poprosić Twój program o uruchomienie funkcji, a następnie kontynuować wynikiem. Opisujesz narzędzie, sprawdzasz, czy odpowiedź zawiera wywołanie, uruchamiasz je i wysyłasz wynik z powrotem z rolą tool.

# client from step 1: base_url https://api.fluxapikey.com/v1
import json

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

messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = len(args["text"].split())
        messages.append({"role": "tool", "tool_call_id": call.id, "content": str(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, ponieważ model może zwrócić wywołanie, którego nie spodziewałeś się. Wywołania narzędzi również strumieniują się jako delty tool_calls, jeśli jest to potrzebne. Dokumentacja wymienia każde pole.

Krok 6: obsłuż limity i błędy

Pełny klucz pozwala na 8 równoległych zapytań i 300 na minutę; klucz próbny pozwala na 2 i 60. Przekroczenie granicy powoduje odpowiedź API HTTP 429. Kod błędu to rate_limited dla zbyt wielu zapytań na minutę i concurrency dla zbyt wielu naraz. Przy tymczasowym przeciążeniu otrzymujesz również 429 z nagłówkiem Retry-After: 5. Mały wrapper do ponawiania obsługuje wszystkie trzy przypadki:

# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError

def ask(messages, tries=4):
    for i in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError:
            time.sleep(5 * (i + 1))
    raise RuntimeError("still limited after retries")

Jeśli uruchamiasz zadania w wątkach, ogranicz je do 8 za pomocą ThreadPoolExecutor(max_workers=8), aby rzadko osiągać limit równoległości. Każda odpowiedź zawiera X-Request-Id, który należy podać przy kontakcie z wsparciem, a X-Balance-USD pokazuje pozostały kredyt. Maksymalny rozmiar treści żądania to 8 MB.

Ustawienia zmieniające wynik

Większość codziennego strojenia odbywa się w garści parametrów, wszystkich przekazywanych do modelu.

  • temperature kontroluje losowość. Użyj 0,2 lub mniej do ekstrakcji i klasyfikacji, około 0,7 do rozmowy, i 1,0 lub więcej do burzy mózgów i fikcji.
  • top_p obcina mało prawdopodobny ogon wyborów słów. Zmień albo to, albo temperaturę, nie oba naraz, aby wiedzieć, który parametr zadziałał.
  • seed sprawia, że powtarzalne uruchomienia są bardziej porównywalne. Jest przydatny w testach, gdzie chcesz zobaczyć efekt zmiany promptu i nie hałasu.
  • stop kończy generowanie na ciągu, który wybierzesz, co jest przydatne do odcięcia modelu, który ciągle dodaje komentarze.
  • max_tokens jest opcjonalny. Bez niego wygenerowany tekst może wykorzystać wszystko, co zostało z okna 100 000 tokenów. Ustaw go, gdy chcesz mieć twardy limit długości i kosztu.
  • Kary za częstotliwość i obecność zniechęcają do powtórzeń, co pomaga przy długich tekstach twórczych, które zaczynają się zapętlać.

Zapisz ustawienia, których użyłeś obok dowolnego wyniku, na którym Ci zależy. Po miesiącach „dlaczego odpowiedział inaczej” to prawie zawsze zmieniony parametr lub zmieniona wiadomość systemowa.

Wysyłanie wielu zapytań naraz

Pętla wysyłająca jedno zapytanie na raz marnuje większość przydzielonego limitu. Z pełnym kluczem możesz mieć 8 zapytań w locie, więc pula wątków skraca czas rzeczywisty wykonania długiego batcha do około jednej ósmej.

from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

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

def summarise(text):
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": "Summarise in one line: " + text}],
        max_tokens=60,
    )
    return r.choices[0].message.content

texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
    for line in pool.map(summarise, texts):
        print(line)

Utrzymaj liczbę workerów na poziomie 8 lub mniej, albo 2 w przypadku klucza próbnego. Jeśli nadal widzisz odpowiedzi 429 z kodem concurrency, zmniejsz liczbę o jeden lub dwa. Limit 300 na minutę ma znaczenie przy szybkich, krótkich zapytaniach, więc pula drobnych wywołań może go osiągnąć zanim wyczerpie się limit równoległości.

Powszechne problemy i rozwiązania

Większość błędów pierwszego dnia pochodzi z krótkiej listy przyczyn.

  • 401 lub błąd uwierzytelnienia. Klucz jest nieobecny, wpisany błędnie lub wysłany pod niewłaściwy host. Wypisz adres URL bazowy, którego faktycznie używa Twój klient, i upewnij się, że kończy się na /v1.
  • Model nie znaleziony. ID modelu musi być uncensored. Wywołaj GET /v1/models, jeśli chcesz sprawdzić, jakie modele wypisuje serwer.
  • Pusta lub ucięta odpowiedź. Niski max_tokens zatrzymuje odpowiedź w połowie zdania. Podnieś go lub usuń. Sprawdź finish_reason przy wyborze: length oznacza, że limit został osiągnięty.
  • JSON, którego nie można sparsować. Albo odpowiedź została ucięta, albo prompt nie opisał struktury. Najpierw napraw prompt, a parsowanie opakuj w blok try.
  • Powolny pierwszy token. Bardzo długi prompt zajmuje więcej czasu do przetworzenia. Przycinaj historię lub wysyłaj mniej kontekstu.
  • Zapytanie za duże. Limit rozmiaru treści żądania to 8 MB, a okno tokenów to 100 000. Podziel duże dokumenty na części i zsumaryzuj każdą z nich.

Gdy coś nadal wygląda źle, zaloguj nagłówek X-Request-Id wraz z nieudanym zapytaniem. Pozwoli to wsparciu znaleźć dokładnie to zapytanie.

Koszt

Płacisz $0.15 za 1M tokenów wejściowych i $0.50 za 1M tokenów wyjściowych z przedpłaconego kredytu. Typowe wywołanie z 2000 tokenami wejściowymi i 500 wyjściowymi kosztuje 0,002 x $0,15 = $0,0003 za wejście plus 0,0005 x $0,50 = $0,00025 za wyjście, czyli łącznie $0,00055. Dziesięć tysięcy takich wywołań kosztuje $5,50. Nieudane lub odrzucone zapytania nie są rozliczane, a kredyt nigdy nie wygasa. Doładowania wynoszą od $20 do $500; zobacz cennik, aby poznać poziomy premii. Prompty nie są używane do trenowania.

Tokeny wyjściowe kosztują więcej niż tokeny wejściowe, więc najtańszą praktyką jest proszenie o krótkie odpowiedzi: powiedz dwa zdania lub tylko JSON i ustaw max_tokens na rozsądny limit. Czytaj resp.usage podczas tworzenia kodu, aby zobaczyć rzeczywiste liczby tokenów dla swoich promptów, i pomnóż przez powyższe stawki przed skalowaniem zadania. Nagłówek X-Balance-USD pokazuje, co zostało po każdym wywołaniu.

Pytania i odpowiedzi

Czy potrzebuję GPU do implementacji LLM w Pythonie?

Nie przy użyciu hostowanego API. Twój kod Pythona tylko wysyła żądania HTTP, więc wystarczy dowolny laptop.

Czy mogę użyć oficjalnego pakietu openai?

Tak. Ustaw base_url na URL usługi i api_key na swój klucz, a następnie użyj ID modelu uncensored.

Czy obsługuje kod asynchroniczny?

Klient AsyncOpenAI w SDK działa z tym samym adresem URL bazowym i kluczem. Utrzymaj liczbę równoległych zapytań na poziomie 8 lub mniej.

Jak mogę go wypróbować bez płacenia?

Zarejestruj się i odebierz $0,50 kredytu próbnego na stronie klucza. Jest ważny przez 7 dni i nie wymaga karty.

Twój klucz jest o jeden formularz stąd

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

Pobierz klucz API