PL ▾
Pobierz klucz API

Przykłady GLM API: Python, tryb JSON i strumieniowanie

Te przykłady GLM API działają na jednym endpointzie kompatybilnym z OpenAI, z base URL https://api.glmapikey.com/v1 i modelem uncensored. Każdy fragment jest krótki i samodzielny, więc możesz go wkleić, dodać swój klucz i uruchomić.

Zaktualizowano

Terminal strumieniujący świecące tokeny danych do serwera w chmurze, ilustrujący przykłady kodu API

Kluczowe punkty

  • Każdy przykład używa base URL https://api.glmapikey.com/v1, uwierzytelniania bearer i identyfikatora modelu uncensored.
  • Strumieniowanie, tryb JSON i wywoływanie funkcji są obsługiwane na tym samym endpointzie chat completions.
  • Czytaj X-Balance-USD i blok użycia, aby śledzić wydatki na każde zapytanie.
  • Obsługuj błąd 429 w kodzie: rate_limited, concurrency lub przeciążenie z Retry-After: 5.

Zanim uruchomisz cokolwiek

Potrzebujesz tylko klucza. Utwórz go na stronie klucza API; nowe konta mogą jednym kliknięciem uzyskać $0,50 kredytu próbnego bez karty. Wyeksportuj go, aby przykłady mogły go odczytać:

export API_KEY="YOUR_KEY"
pip install openai
npm install openai

API stosuje format OpenAI chat completions. Udostępnia POST /v1/chat/completions oraz GET /v1/models, akceptuje nagłówek Authorization: Bearer i obsługuje jeden model o identyfikatorze uncensored. To model o otwartych wagach uruchamiany przez niezależnego dostawcę, dostrojony do odpowiadania bez odmów treści dla prawnego użytku przez osoby dorosłe. Nie jest to oficjalne API żadnego dostawcy modeli. Obsługuje tylko tekst: bez obrazów, audio, embeddingów ani dostrajania.

Poniższe przykłady przechodzą od najprostszego zapytania do wywoływania funkcji. Jeśli potrzebujesz tylko najkrótszej możliwej weryfikacji działania klucza, wystarczy pierwsze polecenie curl.

Pierwsze zapytanie curl i istotne parametry

curl https://api.glmapikey.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 assistant."},
      {"role": "user", "content": "What is a mutex, in one sentence?"}
    ],
    "temperature": 0.3,
    "max_tokens": 80
  }'

Odpowiedź to obiekt JSON z choices[0].message.content zawierającym odpowiedź i obiektem usage z prompt_tokens i completion_tokens. Nagłówki odpowiedzi zawierają X-Request-Id, X-Balance-USD oraz dwa nagłówki X-RateLimit-Limit. Dodaj -i do curl, aby je zobaczyć.

Pola temperature, top_p, stop, seed oraz kary obecności i częstotliwości są przekazywane do modelu. max_tokens jest opcjonalne. Bez niego uzupełnienie może wykorzystać wszystko, co zostało z okna 100 000 tokenów po Twoim prompcie.

Treść żądania chat completions zawiera wiele opcjonalnych pól, ale pięć z nich odpowiada za większość pracy. Wszystkie są przekazywane do modelu.

PoleCo to robiTypowe zastosowanie
temperatureWyższe wartości dają bardziej zróżnicowane sformułowania0.2 do ekstrakcji, 0.8 do fikcji
top_pOgranicza próbkowanie do najbardziej prawdopodobnych tokenówZostaw domyślnie, chyba że go dostrojysz
stopKończy odpowiedź, gdy pojawi się dany ciągUcięcie po separatorze, np. pustej linii
seedUmożliwia powtarzalność próbkowania w najlepszym możliwym zakresiePorównanie dwóch wersji promptu
presence_penalty, frequency_penaltyZniechęca do powtarzania tokenówMałe wartości, np. 0.3, gdy tekst się zapętla

Zmieniaj jedną wartość naraz i zachowaj ten sam prompt, inaczej nie będziesz wiedzieć, która zmiana pomogła. W przypadku generowania kodu, np. klasyfikacji lub ekstrakcji, użyj niskiej temperatury i ustalonej wartości początkowej, aby móc ponownie uruchomić test i uzyskać ten sam wynik. Przy pisaniu twórczym podnieś temperaturę i pozwól karom ograniczyć powtarzalność.

Pole max_tokens jest tutaj opcjonalne. Jeśli je pominiesz, odpowiedź może wykorzystać całą dostępną przestrzeń w oknie 100 000 tokenów, co rzadko jest pożądane przy krótkiej odpowiedzi. Ustaw je, gdy wiesz, jaka powinna być długość odpowiedzi.

Python: rozmowa z pamięcią

API jest bezstanowe, więc to Ty zarządzasz rozmową i wysyłasz ją za każdym razem. Ta pętla utrzymuje listę wiadomości i dodaje obie strony:

from openai import OpenAI

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

messages = [{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user = input("you> ")
    if not user:
        break
    messages.append({"role": "user", "content": user})
    resp = client.chat.completions.create(model="uncensored", messages=messages)
    reply = resp.choices[0].message.content
    messages.append({"role": "assistant", "content": reply})
    print("bot>", reply)

Ponieważ każde wywołanie wysyła pełną listę, tokeny wejściowe rosną wraz z długością rozmowy. Przy cenie $0,15 za 1 mln tokenów wejściowych jest to tanie, ale w długich sesjach kwota się sumuje, więc usuń stare wiadomości, gdy wątek przekroczy rozmiar, za który chcesz płacić. Na stronie z cenami znajdziesz przykłady.

Strumieniowanie w Pythonie i Node

Ustaw stream: true, a serwer wysyła tokeny w miarę ich generowania za pomocą zdarzeń wysyłanych przez serwer. W Pythonie:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write four lines about the sea."}],
    stream=True,
)

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

Strumień kończy się informacjami o użyciu, dlatego pętla je sprawdza. To samo w Node:

import OpenAI from "openai";

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

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Write four lines about the sea." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Jedna kwestia dotycząca limitów: żądanie strumieniowe zajmuje slot współbieżności do momentu zakończenia strumienia. Jeśli zaczniesz strumieniowanie i nie odczytasz go do końca, slot pozostaje zajęty. Zawsze pobieraj lub zamykaj strumień.

Tryb JSON dla strukturalnego outputu

Gdy Twój kod musi sparsować odpowiedź, poproś o obiekt JSON z response_format. W promptie określ też, jaki kształt ma mieć odpowiedź, ponieważ flaga formatu gwarantuje poprawną składnię JSON, a nie Twoją konkretny schemat.

import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
        {"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
    ],
    temperature=0.2,
)

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

Sprawdź, czy potrzebne klucze istnieją, zanim ich użyjesz, i utrzymaj niską temperaturę przy ekstrakcji. Jeśli parsowanie się nie powiedzie, ponowne wysłanie tego samego zapytania zwykle działa, a nieudane zapytania nie są rozliczane.

Wywoływanie funkcji: pełna pętla

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

import json

def get_weather(city: str) -> dict:
    return {"city": city, "temp_c": 18, "sky": "cloudy"}

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(get_weather(**args)),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

Funkcja zwraca tutaj dane stałe, więc zamień ją na prawdziwe wyszukiwanie. Argumenty funkcji przychodzą jako ciąg JSON, więc zawsze je parsuj i waliduj wartości przed ich użyciem. Przy stream: true wpisy tool_calls przychodzą w kawałkach, które musisz złożyć przed parsowaniem. Użyj tool_choice, aby wymusić konkretne narzędzie, gdy jest to potrzebne.

Koszt przykładów i błędy marnujące godzinę

Uruchamianie przykładów kosztuje bardzo mało, ale warto zobaczyć rachunek raz. Przy cenie $0,15 za 1 mln tokenów wejściowych i $0,50 za 1 mln tokenów wyjściowych:

  • Pętla rozmowy z promptem 1200 tokenów i odpowiedzią 300 tokenów: $0,00018 za wejście plus $0,00015 za wyjście daje $0,00033. Tysiąc tur kosztuje $0,33.
  • Pętla wywoływania funkcji wykonuje dwa wywołania. Jeśli pierwsze zużywa 400 tokenów wejściowych i 60 wyjściowych, a drugie 500 wejściowych i 150 wyjściowych, sumy to 900 wejściowych i 210 wyjściowych: $0,000135 plus $0,000105 daje $0,00024.
  • Strumieniowanie kosztuje tyle samo co normalne wywołanie z takimi samymi liczbami tokenów. Zmienia się moment, w którym widzisz tekst, a nie koszt.

Kredyt próbny $0,50 wystarczyłby na ponad 1500 tur pętli rozmowy przy tym rozmiarze ($0,50 / $0,00033), więc możesz swobodnie eksperymentować przed doładowaniem. Nieudane i odrzucone zapytania nie są rozliczane, co oznacza, że błąd w parsowaniu, który zmusza Cię do ponownego uruchomienia zapytania, nie kosztuje Cię za nieudane próby.

  • Zły base URL. Musi kończyć się na /v1. Dodanie /chat/completions samodzielnie do base URL SDK daje 404, ponieważ SDK dodaje tę ścieżkę.
  • Inna nazwa modelu. Nazwy skopiowane z innych platform tutaj nie istnieją. ID to uncensored.
  • Oczekiwanie pamięci. API nie pamięta wcześniejszych wywołań. Wysyłaj historię za każdym razem.
  • Interpretacja JSON modelu bez zabezpieczenia. Owiń json.loads w bloku try i przygotuj plan na niepoprawną odpowiedź.
  • Pozostawianie strumieni otwartych. Niezakończony strumień zajmuje slot równoległych zapytań, a klucz próbny ma tylko dwa.
  • Umieszczanie klucza w kodzie front-end. Przechowuj go na serwerze.

Jeśli coś nadal wygląda nieprawidłowo, wyślij zapytanie za pomocą curl i porównaj je z tym, co generuje Twój kod. Wariant z curl usuwa SDK z równania i sprawia, że różnice w treści żądania są oczywiste.

Odczytywanie zużycia, salda i błędów

Aby zobaczyć nagłówki z Python SDK, użyj wrappera surowej odpowiedzi:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("x-request-id"))
print("balance usd:", raw.headers.get("x-balance-usd"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)

Loguj ID zapytania przy każdym wywołaniu, aby móc wskazać pojedyncze zapytanie później. Użyj nagłówka salda, aby wygenerować alert przed wyczerpaniem kredytu.

Po przekroczeniu limitu API zwraca HTTP 429, a kod błędu informuje, który to limit:

Kod lub nagłówekCo zrobićCo zrobić
rate_limitedZbyt wiele zapytań na minutę (300 na pełnym kluczu, 60 na próbnym)Zwolnij i rozłóż wywołania w czasie
concurrencyZbyt wiele naraz (8 na pełnym kluczu, 2 na próbnym)Poczekaj, aż bieżące zapytanie się zakończy
Retry-After: 5Tymczasowe przeciążeniePonów próbę po pięciu sekundach

Nieudane lub odrzucone żądania nie są rozliczane. Treść żądania może mieć rozmiar do 8 MB. Kompletną dokumentację referencyjną oraz sposób ponownego użycia istniejącego kodu klienta znajdziesz w dokumentacji. Przewodnik krok po kroku, jak uzyskać klucz, znajdziesz w artykule o kluczu API GLM.

Pytania i odpowiedzi

Jaki Base URL używają przykłady?

Każdy przykład używa https://api.glmapikey.com/v1 z ID modelu uncensored i tokenem Bearer. Każde SDK OpenAI zadziała po zmianie tych wartości.

Czy API obsługuje strumieniowanie?

Tak. Ustaw stream na true i czytaj zdarzenia wysyłane przez serwer (SSE). Zużycie jest raportowane na końcu strumienia.

Jak uzyskać poprawny JSON?

Przekaż response_format z typem json_object i opisz w prompcie żądaną strukturę. Sparsuj wynik w swoim kodzie i sprawdź potrzebne klucze.

Czy mogę używać wywoływania funkcji?

Tak. Przekaż tools i tool_choice, uruchom funkcję żądaną przez model i zwróć wynik jako wiadomość z role tool.

Gdzie mogę zobaczyć pozostały kredyt?

Każda odpowiedź zawiera nagłówek X-Balance-USD z Twoim pozostałym saldem, a blok zużycia podaje liczbę tokenów.

Twój klucz jest o jeden formularz stąd

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

Pobierz klucz API