PL ▾
Pobierz klucz API

Jak korzystać z modelu LLM przez API krok po kroku

Korzystanie z hostowanego modelu językowego sprowadza się do jednego wywołania HTTP z kluczem, nazwą modelu i listą wiadomości. Ten poradnik przeprowadzi Cię od pustego folderu do strumieniowania, wyjścia JSON i wywołań narzędzi.

Zaktualizowano

Terminal połączony z kostką bąbelków czatu z przesyłanymi między nimi danymi, reprezentujący wywołanie API LLM
01

Kluczowe punkty

  • API jest kompatybilne z OpenAI: zmień Base URL i klucz, zachowaj swoje SDK.
  • Użyj identyfikatora modelu uncensored z POST /v1/chat/completions.
  • Strumieniowanie, tryb JSON i wywoływanie narzędzi działają ze standardowymi parametrami.
  • Kod 429 oznacza przekroczenie limitu, a kod błędu informuje, którego.

Czego potrzebujesz przed pierwszym zapytaniem

Jeśli chcesz wiedzieć, jak korzystać z endpointów modeli LLM we własnym kodzie, wystarczą trzy rzeczy: klucz, Base URL i nazwa modelu. Nie trzeba instalować specjalnego klienta. Działa dowolne OpenAI SDK lub klient, po wskazaniu innego adresu.

  • Podstawowy adres URL: https://api.llmmodelsapi.com/v1
  • Identyfikator modelu: uncensored
  • Autoryzacja: nagłówek Authorization: Bearer YOUR_KEY, który dodają za Ciebie SDK

Aby uzyskać klucz, zarejestruj się przez Google lub e-mail i hasło, a następnie otwórz stronicę kluczy API. Nowe konta mogą jednym kliknięciem odebrać $0,50 darmowego kredytu próbnego bez podawania karty, ważny przez 7 dni. To wystarczy na wszystko w tym artykule. Endpoint obsługuje dwie metody: POST /v1/chat/completions do generowania i GET /v1/models do listowania dostępnych modeli.

Warto wiedzieć, czym jest model, aby Twoje oczekiwania były trafne. To jeden model o otwartych wagach obsługiwany przez niezależnego dostawcę i dostrojony do odpowiadania bez odrzucania treści dla prawnego użytku dorosłego. Nie jest to oficjalne API żadnego dużego dostawcy i obsługuje tylko tekst. Nie ma generowania obrazów ani audio, nie ma embeddingów ani dostrajania.

Krok 1: sprawdź klucz za pomocą curl

Zanim napiszesz kod aplikacji, potwierdź, że klucz i ścieżka sieciowa działają. Wylistowanie modeli to najtańsze sprawdzenie, ponieważ nie generuje żadnych danych.

export LLM_KEY="paste-your-key-here"

# the list should include the model id: uncensored

curl https://api.llmmodelsapi.com/v1/models   -H "Authorization: Bearer $LLM_KEY"

Powinieneś otrzymać listę JSON, która zawiera uncensored. Jeśli widzisz 401, klucz jest nieprawidłowy lub brakuje słowa Bearer. Teraz wyślij prawdziwe żądanie czatu.

curl https://api.llmmodelsapi.com/v1/chat/completions   -H "Authorization: Bearer $LLM_KEY"   -H "Content-Type: application/json"   -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "Explain what a context window is in two sentences."}
    ],
    "max_tokens": 150
  }'

Odpowiedź zawiera tablicę choices, a tekst znajduje się pod choices[0].message.content. Nagłówki odpowiedzi zawierają X-Request-Id i X-Balance-USD, więc możesz zobaczyć swój pozostały kredyt przy każdym wywołaniu. Pole usage pokazuje tokeny policzone do rozliczenia.

Krok 2: wywołaj go z Pythona lub Node

W praktyce użyjesz SDK. Zainstaluj oficjalny pakiet OpenAI, a następnie ustaw base URL przy tworzeniu klienta. Nic innego w Twoim kodzie się nie zmienia.

Python

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You answer in plain language."},
        {"role": "user", "content": "Give me three names for a fantasy tavern."},
    ],
    temperature=0.9,
    max_tokens=200,
)

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

Node

import OpenAI from "openai";

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

const resp = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Summarise HTTP caching in one paragraph." }],
});

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

Przechowuj klucz w zmiennej środowiskowej, a nie w pliku źródłowym. Jeśli klucz wycieknie, zastąp go na stronie klucza, a stary przestanie działać.

Krok 3: kształtuj wynik za pomocą parametrów

Model to predyktor tekstu, więc tak, jak sformułujesz żądanie, ma znaczenie tak samo jak parametry. Kilka nawyków przynosi natychmiastowe efekty.

  • Używaj wiadomości systemowej do zasad stałych. Umieść tam ton, format i rolę, a wiadomość użytkownika zachowaj na właściwe zadanie.
  • Bądź konkretny co do długości. Poproś o „trzy punkty” lub „poniżej 120 słów”. Jest to bardziej niezawodne niż tylko obniżenie max_tokens, które odcina tekst w połowie zdania.
  • Dostosuj temperaturę do zadania. Około 0.2 pasuje do ekstrakcji i klasyfikacji. Około 0,8 do 1,0 pasuje do fikcji i odgrywania ról.
  • Przekazuj to, czego potrzebujesz. top_p, stop, seed oraz kary częstotliwości i obecności są przekazywane do modelu.

Okno kontekstu wynosi 100 000 tokenów, licząc prompt i uzupełnienie łącznie. Nie musisz ustawiać max_tokens, ponieważ odpowiedź może wykorzystać dowolną dostępną przestrzeń. Ustawienie tego parametru to dobry sposób na postawienie sufitu kosztów.

Praktycznym sposobem nauki tych ustawień jest uruchomienie tego samego promptu trzy razy przy różnych temperaturach i porównanie wyników. Zmieniaj jedną wartość na uruchomienie i trzymaj resztę stałą, używając tego samego seed, gdzie to możliwe. Po dziesięciu minutach takiego działania będziesz wiedzieć, jak model zachowuje się w Twoim zadaniu znacznie lepiej niż jakikolwiek opis, a koszt eksperymentu to ułamek centa.

Ceny to $0,15 za milion tokenów wejściowych i $0,50 za milion tokenów wyjściowych. Żądanie z 1 500 tokenami wejściowymi i 400 wyjściowymi kosztuje 1 500 x 0,15 / 1 000 000 = $0,000225 plus 400 x 0,50 / 1 000 000 = $0,0002, czyli łącznie $0,000425. Na stronie z cenami znajdziesz opcje doładowania.

Krok 4: strumieniuj odpowiedź

Czekanie na pełną odpowiedź w interaktywnej aplikacji może być wolne. Dzięki stream: true serwer wysyła tokeny jako zdarzenia wysyłane przez serwer, a Twój interfejs może je wyświetlać w miarę ich przybywania. Zużycie jest raportowane na końcu strumienia.

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short story opening about a lighthouse."}],
    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)

Pamiętaj o jednej rzeczy dotyczącej współbieżności: strumieniowane żądanie zajmuje swoje miejsce do zakończenia strumienia. Pełny klucz pozwala na 8 równoległych zapytań, klucz próbny pozwala na 2. Jeśli otworzysz strumień w przeglądarce i nigdy go nie zamkniesz, to miejsce pozostanie zajęte.

Krok 5: tryb JSON i wywoływanie narzędzi

Gdy inny program musi odczytać odpowiedź, wolny tekst staje się problemem. Tryb JSON prosi model o zwrócenie poprawnego obiektu JSON.

import json
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "Describe a post about growing tomatoes on a balcony."},
    ],
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Opisz też kształt, którego chcesz, w prompcie, ponieważ tryb JSON gwarantuje poprawną składnię, a nie dokładne nazwy pól. Opakuj parsowanie w blok try i ponów próbę raz, jeśli się nie powiedzie.

Wywoływanie narzędzi pozwala modelowi poprosić Twój kod o uruchomienie funkcji. Opisujesz narzędzia, model odpowiada wpisem tool_calls, uruchamiasz go i wysyłasz wynik z powrotem jako wiadomość z role: "tool".

import json
from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "get_time",
        "description": "Return the current time for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
call = first.choices[0].message.tool_calls[0]

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps({"time": "14:05"}),
})

final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)

W produkcji sprawdź, czy tool_calls jest obecny przed odwołaniem się do niego, ponieważ model może odpowiedzieć bezpośrednio, zamiast wywołać funkcję. Parametr tool_choice pozwala wymusić lub zabronić wywołania, gdy tego potrzebujesz.

Kontynuowanie konwersacji

API nie ma pamięci między wywołaniami. Jeśli chcesz, aby model pamiętał, co powiedziano dwa kroki temu, wyślij te kroki ponownie. Aplikacja czatu jest więc listą, która rośnie: dodajesz wiadomość użytkownika, wywołujesz API, dodajesz odpowiedź asystenta i powtarzasz.

from openai import OpenAI

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key="YOUR_KEY")
history = [{"role": "system", "content": "You are a friendly writing coach."}]

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

print(say("Give me a tip for opening a short story."))
print(say("Now apply it to a story about a night train."))

Ponieważ każde wywołanie zawiera całą listę, koszt i opóźnienie rosną wraz z rozmową. Gdy historia jest długa, usuń najstarsze wiadomości lub zastąp je podsumowaniem w jednym akapicie. Masz dużo miejsca, ponieważ 100 000 tokenów to mniej więcej długość krótkiej powieści, ale nie ma powodu płacić za tokeny, które już nie pomagają w odpowiedzi.

Z tego samego powodu trzymaj wiadomość systemową krótką i stabilną. Jest wysyłana przy każdym wywołaniu, więc 1 000 tokenów wiadomości systemowej przy 500 żądaniach to 500 000 tokenów wejściowych, co samo w sobie kosztuje 500 000 x 0,15 / 1 000 000 = $0,075.

Błędy początkujących

  • Zapominanie o dodaniu odpowiedzi asystenta. Model widzi wtedy tylko Twoje pytania i traci wątek.
  • Umieszczanie sekretów we frontendzie. Klucz w kodzie przeglądarki jest widoczny dla każdego. Wywołuj API ze swojego serwera i udostępnij własny endpoint zamiast tego.
  • Oczekiwanie faktów od predyktora tekstu. Model może podać błędne szczegóły z pewnością. Podaj tekst źródłowy w prompcie, gdy zależy Ci na dokładności, i sprawdź ważne odpowiedzi.
  • Parsowanie wolnego tekstu. Jeśli kod musi odczytać odpowiedź, użyj trybu JSON lub wywołania narzędzia zamiast wyrażeń regularnych.

Błędy, limity i co dalej

Większość problemów mieści się na krótkiej liście.

ObjawPrawdopodobna przyczynaNaprawa
Odpowiedź 401Brakujący lub nieprawidłowy kluczSprawdź nagłówek Bearer i klucz na stronie klucza
429, kod rate_limitedPowyżej 300 zapytań na minutę (60 na kluczu próbnym)Zwolnij lub zaplanuj zapytania
429, kod concurrencyPowyżej 8 żądań naraz (2 na kluczu próbnym)Ogranicz liczbę równoległych żądań, zamykaj otwarte strumienie
429 z Retry-After: 5Tymczasowe przeciążeniePoczekaj 5 sekund i ponów
Zapytanie zbyt dużeTreść przekracza 8 MBWysyłaj mniej tekstu w jednym zapytaniu

Proste ponowienie z krótkim opóźnieniem rozwiązuje przypadki 429. Nieudane zapytania nie są rozliczane, więc ponawianie nie generuje dodatkowych kosztów. Prompty nie są używane do trenowania.

Stąd dokumentacja API wymienia każdy parametr, a przegląd opłaty za token opisuje, dla kogo jest usługa. Jedna zasada obowiązuje wszędzie: treść seksualna z udziałem nieletnich jest nigdy dozwolona.

02

Pytania i odpowiedzi

Jaki model ID wysyłam w zapytaniu?

Używaj uncensored jako wartości modelu w każdym zapytaniu. Możesz to potwierdzić, wywołując GET /v1/models.

Czy potrzebuję specjalnego SDK?

Nie. Działa dowolne SDK lub klient OpenAI po zmianie base URL na https://api.llmmodelsapi.com/v1 i użyciu własnego klucza.

Czy mogę korzystać bez karty kredytowej?

Tak, do testów. Nowi użytkownicy mogą jednym kliknięciem odebrać $0.50 kredytu próbnego po rejestracji, bez karty, ważny przez 7 dni.

Jak duży może być mój prompt?

Okno kontekstu wynosi 100 000 tokenów dla promptu i uzupełnienia łącznie, a ciało zapytania może mieć do 8 MB.

Twój klucz jest o jeden formularz stąd

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

Pobierz klucz API