how-tos

Przewodnik po GPT-6.2 API: pierwsze żądanie w cURL i Pythonie, Responses i Chat Completions

Poyo.ai Team
8 min read
Share:

Przewodnik po GPT-6.2 API: pierwsze żądanie w cURL i Pythonie

Ten przewodnik po GPT-6.2 API prowadzi od klucza API do działającego żądania do gpt-6.2-sol lub gpt-6.2-astra w cURL i w Python OpenAI SDK, na obu endpointach: Responses i Chat Completions. Każde ciało żądania odpowiada opublikowanemu schematowi PoYo i uwagom OpenAI o migracji na GPT-6.2 według stanu z 18 listopada 2026. Prompty możesz najpierw przetestować na stronie modelu GPT-6.2 Sol lub stronie modelu GPT-6.2 Astra.

Nie znasz jeszcze tych modeli? Przegląd GPT-6.2 API opisuje limity i pozycjonowanie.

Zanim zaczniesz

Utwórz klucz w panelu PoYo i trzymaj go na serwerze:

export POYO_API_KEY="your-poyo-key"
FormatEndpointKiedy go używać
ResponsesPOST https://api.poyo.ai/v1/responsesNowy kod, function tools, obrazy na wejściu, poziom rozumowania
Chat CompletionsPOST https://api.poyo.ai/v1/chat/completionsIstniejący kod Chat Completions, wiadomości tylko tekstowe, bez narzędzi

Każde żądanie wysyła Authorization: Bearer $POYO_API_KEY. Przykłady używają gpt-6.2-sol; dla Astra zamień go na gpt-6.2-astra. Struktura żądań jest identyczna.

Trzy zasady z przewodnika OpenAI po GPT-6.2 dotyczą każdego przykładu poniżej:

  1. Nie wysyłaj temperature ani top_p. OpenAI zaleca ich pominięcie, a także logprobs i top_logprobs w Chat Completions oraz top_logprobs w Responses. Schematy PoYo nadal wymieniają temperature i top_p dla starszych modeli.
  2. Nie ustawiaj poziomu rozumowania na none; API go odrzuca.
  3. Stałe instrukcje umieszczaj w wiadomości developer na początku input. GPT-6.2 dołącza instructions najwyższego poziomu po input, co wyrzuca je z prefiksu, który da się zcache'ować.

Pierwsze żądanie do GPT-6.2 API w cURL

curl https://api.poyo.ai/v1/responses \
  -H "Authorization: Bearer $POYO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.2-sol",
    "input": [
      {"role": "developer", "content": "You are a code reviewer. Be specific and cite line numbers."},
      {"role": "user", "content": "Review this function for race conditions: ..."}
    ],
    "reasoning": {"effort": "medium"},
    "max_output_tokens": 8000,
    "store": false
  }'

model i input są wymagane. input to zwykły ciąg znaków albo tablica elementów z role (developer, system, user, assistant) i content. Inne udokumentowane pola używane w tym przewodniku to reasoning, max_output_tokens, stream, store, tools, tool_choice, previous_response_id i metadata.

Odpowiedzią jest obiekt Responses zwracany bezpośrednio. Tekst znajduje się w blokach output[].content[] z type: "output_text", status wywołania w status, a liczby tokenów w usage.input_tokens, usage.output_tokens i usage.total_tokens.

Python z OpenAI SDK

Skieruj SDK na PoYo:

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.poyo.ai/v1", api_key=os.environ["POYO_API_KEY"])

resp = client.responses.create(
    model="gpt-6.2-sol",
    input=[
        {"role": "developer", "content": "You are a senior backend engineer."},
        {"role": "user", "content": "Write a migration plan from Celery 4 to Celery 5."},
    ],
    reasoning={"effort": "medium"},
    max_output_tokens=8000,
)

print(resp.output_text)
print(resp.status, resp.usage)

resp.output_text to pomocnicza właściwość SDK, która łączy wszystkie bloki output_text. Loguj resp.usage przy każdym wywołaniu; korzysta z niego sekcja o koszcie poniżej.

Chat Completions dla istniejącego kodu

Jeśli twój kod już używa chat.completions.create, zmień model i usuń pola próbkowania:

resp = client.chat.completions.create(
    model="gpt-6.2-sol",
    messages=[
        {"role": "system", "content": "You are a senior backend engineer."},
        {"role": "user", "content": "Explain the CAP theorem with one example per trade-off."},
    ],
    max_tokens=4000,
)
print(resp.choices[0].message.content, resp.choices[0].finish_reason)

To samo żądanie w cURL:

curl https://api.poyo.ai/v1/chat/completions \
  -H "Authorization: Bearer $POYO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.2-sol",
    "messages": [{"role": "user", "content": "Explain vector databases in one sentence."}],
    "max_tokens": 1000
  }'

Schemat Chat Completions w PoYo opisuje model, messages (content jako ciąg znaków; role system, user, assistant), max_tokens, stream, stop, n oraz pola kar. Nie opisuje tools, a OpenAI podaje, że wywoływanie narzędzi w GPT-6.2 wymaga Responses, więc agenci powinni korzystać z /v1/responses.

Ustawianie poziomu rozumowania w GPT-6.2 API

OpenAI nazywa to pole reasoning.effort w Responses i reasoning_effort w Chat Completions. Dokumentacja Responses w PoYo opisuje reasoning (przykład {"effort": "medium"}); dokumentacja Chat Completions nie wymienia jeszcze reasoning_effort, więc ten przewodnik ustawia poziom tylko w Responses.

SytuacjaUstawienieŹródło
Nowa integracjamediumOpenAI: „Zacznij od medium w nowej integracji”.
Wcześniej none lub minimallowUwaga OpenAI o migracji na GPT-6.2
Długie lub złożone zadaniaWyższy poziomOpenAI: wyższy poziom „może pomóc modelowi wytrwać aż do końcowych sprawdzeń”
noneOdrzucaneStrony modeli OpenAI

Przewodnik OpenAI po rozumowaniu wymienia wśród możliwych wartości low, medium, high, xhigh i max, ale zaznacza, że zależą one od modelu. Strony modeli GPT-6.2 nie podają akceptowanego zestawu, więc wyślij jedno testowe żądanie, zanim na stałe wpiszesz poziom wyższy niż medium. Tokeny rozumowania są rozliczane jak wyjście i wliczają się do max_output_tokens; OpenAI raportuje je w usage.output_tokens_details.reasoning_tokens.

Streaming odpowiedzi GPT-6.2 API

Przy "stream": true PoYo zwraca text/event-stream. Każda linia data: to JSON, którego type nazywa zdarzenie; tekst przychodzi jako response.output_text.delta, a response.completed niesie końcowy obiekt z usage. PoYo nie wysyła osobnych linii event:, a strumień kończy się data: [DONE].

stream = client.responses.create(
    model="gpt-6.2-sol",
    input="Write a 100-word product introduction for a log search tool.",
    reasoning={"effort": "low"},
    max_output_tokens=2000,
    stream=True,
    store=False,
)

usage = None
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
    elif event.type == "response.completed":
        usage = event.response.usage
    elif event.type == "response.failed":
        raise RuntimeError(event.response)
print("\n", usage)

W Chat Completions stream=True zwraca zdarzenia chat.completion.chunk; tekst jest w choices[0].delta.content, a ostatni chunk zawiera usage.

Obrazy na wejściu

GPT-6.2 przyjmuje obrazy razem z tekstem. W PoYo wysyłaj je do Responses jako bloki input_image z publicznym URL lub pełnym Data URI (data:image/png;base64,...). Dokumentacja PoYo zaleca umieszczanie tekstu przed obrazami:

{
  "model": "gpt-6.2-sol",
  "input": [
    {
      "role": "user",
      "content": [
        {"type": "input_text", "text": "List every service in this architecture diagram that writes to the database."},
        {"type": "input_image", "image_url": "https://example.com/diagram.png"}
      ]
    }
  ],
  "max_output_tokens": 3000
}

Odczyt usage i obliczanie kosztu żądania

Ceny PoYo za 1M tokenów: Sol $1.60 za wejście, $8 za wyjście, $0.08 za odczyt z cache, $2 za zapis do cache; Astra $6.40, $32, $0.32, $8 (1 kredyt = $0.005).

Przewodnik OpenAI po cache'owaniu raportuje rozliczane odczyty z cache w usage.input_tokens_details.cached_tokens, a zapisy w usage.input_tokens_details.cache_write_tokens. Schemat PoYo zawiera input_tokens_details i output_tokens_details, ale nie wymienia ich kluczy, więc odczytuj je defensywnie:

PRICES = {  # PoYo USD per 1M tokens: input, output, cache read, cache write
    "gpt-6.2-sol":   (1.60, 8.00, 0.08, 2.00),
    "gpt-6.2-astra": (6.40, 32.00, 0.32, 8.00),
}

def estimate_cost_usd(model: str, usage) -> float:
    p_in, p_out, p_read, p_write = PRICES[model]
    details = getattr(usage, "input_tokens_details", None)
    cached = getattr(details, "cached_tokens", 0) or 0
    written = getattr(details, "cache_write_tokens", 0) or 0
    fresh = usage.input_tokens - cached - written
    return (fresh * p_in + cached * p_read + written * p_write
            + usage.output_tokens * p_out) / 1_000_000

Traktuj to jako szacunek i porównuj z logiem użycia w PoYo. Każda cena podana tutaj to stawka dla krótkiego kontekstu. Powyżej 272K tokenów wejściowych OpenAI pobiera więcej, więc przy tak dużych żądaniach sprawdzaj stronę modelu. Przeliczone przykłady znajdziesz w artykule Cennik GPT-6.2 API.

Błędy, które warto obsłużyć

HTTPPrzyczynaCo zrobić
400Nieprawidłowe pole (validation_error, ze szczegółami)Popraw ciało żądania; tu może trafić poziom none lub nieudokumentowane pole
401Brak klucza API lub nieprawidłowy kluczSprawdź nagłówek Authorization
402Za mało kredytówDoładuj konto przed ponowieniem
404Nieznany model (model_not_found)Sprawdź ID: gpt-6.2-sol, gpt-6.2-astra
429Przekroczony limit żądańOdczekaj i ponów
500 / 502 / 503Błąd serwera lub dostawcy nadrzędnegoPonów z wykładniczym backoffem

Dokumentacja PoYo podaje, że endpointy LLM obecnie nie mają limitów żądań, ale i tak obsłuż 429. W OpenAI SDK łap openai.APIStatusError i rozgałęziaj według status_code. Ponawiaj tylko 5xx i 429; błąd 400 będzie się powtarzał, dopóki nie zmienisz ciała żądania. Pełne treści odpowiedzi znajdziesz w kodach błędów PoYo.

Lista kontrolna przed wdrożeniem

  • Trzymaj POYO_API_KEY po stronie serwera; nigdy nie umieszczaj go w kodzie przeglądarkowym ani mobilnym.
  • Usuń temperature i top_p z każdej ścieżki żądań do GPT-6.2, także ze współdzielonych funkcji pomocniczych.
  • Zawsze ustawiaj max_output_tokens (lub max_tokens) i zostaw w tym limicie miejsce na tokeny rozumowania.
  • Loguj status / finish_reason i cały blok usage obok własnego ID żądania, aby widzieć ucięte odpowiedzi i skoki kosztów.
  • Umieszczaj długi, stały kontekst w pierwszej wiadomości developer, a zmieniające się pytanie na końcu; daje to cache'owaniu promptów szansę zadziałać.
  • Trzymaj ID modelu w konfiguracji, aby przełączać się między gpt-6.2-sol a gpt-6.2-astra bez wdrożenia.

O narzędziach, streamingu wywołań narzędzi i cache'owaniu w długich sesjach agentowych przeczytasz dalej w artykule GPT-6.2 API dla agentów programistycznych.

Najczęściej zadawane pytania

Jak wywołać GPT-6.2 API w Pythonie?

Użyj OpenAI SDK z base_url="https://api.poyo.ai/v1", swoim kluczem PoYo i model="gpt-6.2-sol" lub "gpt-6.2-astra" w client.responses.create.

Czy GPT-6.2 API obsługuje streaming?

Tak, na obu endpointach. Ustaw stream: true; Responses wysyła typowane zdarzenia, takie jak response.output_text.delta, a Chat Completions zdarzenia chat.completion.chunk. Oba strumienie kończą się data: [DONE].

Jak ustawić poziom rozumowania w GPT-6.2 API?

Wyślij "reasoning": {"effort": "medium"} do /v1/responses. OpenAI zaleca start od medium i odrzuca none.

Dlaczego moje żądanie do GPT-6.2 API z temperature kończy się błędem?

OpenAI zaleca pominięcie temperature i top_p dla GPT-6.2. Usuń je i kontroluj długość odpowiedzi przez max_output_tokens lub max_tokens.

Jak wysłać obraz do GPT-6.2 API?

Użyj /v1/responses z blokiem input_image (URL lub Data URI) po bloku input_text. Schemat Chat Completions w PoYo opisuje tylko content jako ciąg znaków.

Share: