Przejdź do głównej treści
Polski— Wybierz język
Menu

Limit czasu, parametry zabronione i konfiguracja

Lekcja 11 z 12 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Poprawnie konfiguruj żądania rozumowania
  2. Limit czasu: co najmniej 900 sekund
  3. Parametry zabronione w modelach rozumowania
  4. Obsługa błędów związanych z parametrami
  5. Strumieniowanie z modelami rozumowania
  6. Kluczowe wnioski

Zaktualizowano 3 listopada 2026 r. Zgodnie z najlepszymi praktykami xAI i przewodnikiem Reasoning: zalecany czas oczekiwania wynosi co najmniej 900 sekund (w przykładach 3600), a nie „minimum 3600 sekund“; lista modeli rozumujących obejmuje grok-4.6 i grok-4.7; grok-4.7 strumieniuje podsumowanie swojego rozumowania; usunięto uzasadnienia dotyczące parametrów zabronionych, których nie ma w dokumentacji. Źródła: Najlepsze praktyki · Reasoning.

Poprawnie konfiguruj żądania rozumowania

Modele rozumowania mają specyficzne ograniczenia, których nie posiadają modele klasyczne. Ignorowanie tych zasad może prowadzić do cichych błędów, nieoczekiwanych przekroczeń czasu oczekiwania lub uciętych odpowiedzi. Ta lekcja omawia kluczowe parametry konfiguracyjne.

Limit czasu: co najmniej 900 sekund

Najlepsze praktyki xAI wymagają ustawienia co najmniej 900 sekund na żądanie, a w przypadku długich ewaluacji – 1800 sekund lub więcej; przykłady w przewodniku Reasoning ustawiają ten limit nawet na 3600 sekund (1 godzina). Liczby te mogą wydawać się wysokie, ale odzwierciedlają rzeczywistość: głębokie rozumowanie nad złożonym problemem może trwać kilka minut. xAI zaleca również preferowanie strumieniowania, które utrzymuje aktywne połączenie podczas długich generacji.

Dlaczego tak długi limit czasu?

Gdy model rozumowania przetwarza trudny problem (dowód matematyczny, złożona analiza kodu, rozumowanie wieloetapowe), potencjalnie generuje tysiące wewnętrznych tokenów rozumowania, zanim sformułuje odpowiedź. Proces ten jest liniowy i nie można go zrównoleglić.

Konfiguracja limitu czasu

import httpx
from openai import OpenAI

# Konfiguracja z wysokim limitem czasu
client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

W JavaScript z użyciem SDK OpenAI:

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'your-api-key',
  baseURL: 'https://api.x.ai/v1',
  timeout: 3600 * 1000  // 3600 sekund w milisekundach
});

Limit czasu serwera WWW

Jeśli Twoja aplikacja działa za serwerem proxy odwrotnym (nginx, Apache), skonfiguruj również limit czasu po stronie serwera:

# nginx
location /api/ {
    proxy_read_timeout 3600s;
    proxy_connect_timeout 10s;
    proxy_send_timeout 3600s;
}

Parametry zabronione w modelach rozumowania

Trzy parametry powszechnie używane w modelach klasycznych nie mogą być wysyłane do modeli rozumowania xAI: zgodnie z przewodnikiem Reasoning, żądanie zawierające którykolwiek z nich zwróci błąd. Dokumentacja nie podaje przyczyny tych zakazów; zapamiętaj tę regułę.

presencePenalty

// BŁĄD w modelach rozumowania
{
  "model": "grok-4.20-0309-reasoning",
  "presence_penalty": 0.5,  // Zabronione!
  "messages": [...]
}

presencePenalty nakłada karę na tokeny, które już pojawiły się w odpowiedzi, aby zachęcić do różnorodności.

frequencyPenalty

// BŁĄD w modelach rozumowania
{
  "model": "grok-4.20-0309-reasoning",
  "frequency_penalty": 0.3,  // Zabronione!
  "messages": [...]
}

frequencyPenalty nakłada karę na tokeny proporcjonalnie do częstotliwości ich występowania.

stop

// BŁĄD w modelach rozumowania
{
  "model": "grok-4.20-0309-reasoning",
  "stop": ["\n\n"],  // Zabronione!
  "messages": [...]
}

Parametr stop przerywa generowanie po pojawieniu się określonej sekwencji. Aby ograniczyć długość odpowiedzi, użyj zamiast tego max_completion_tokens, który ogranicza tylko widoczną odpowiedź, oraz instrukcji formatowania w prompcie.

Obsługa błędów związanych z parametrami

Podczas migracji istniejącego kodu do modelu rozumowania wyczyść nieobsługiwane parametry:

def prepare_params(model, base_params):
    """Czyści parametry dla modeli rozumowania."""
    reasoning_models = [
        # obecny zakres
        "grok-4.7", "grok-4.6", "grok-4.5", "grok-4.20-0309-reasoning",
        # historyczne identyfikatory, nadal obecne w istniejącym kodzie
        "grok-3-mini", "grok-4-fast-reasoning",
    ]

    params = {**base_params, "model": model}

    if model in reasoning_models:
        # Usuń parametry zabronione
        for forbidden in ["presence_penalty", "frequency_penalty", "stop"]:
            params.pop(forbidden, None)

        # Zamień max_tokens na max_completion_tokens
        if "max_tokens" in params:
            params["max_completion_tokens"] = params.pop("max_tokens")

    return params

Strumieniowanie z modelami rozumowania

Strumieniowanie działa z modelami rozumowania, ale zachowanie zależy od generacji: w grok-3-mini (poprzednia generacja) reasoning_content pojawiał się w strumieniu w postaci jawnej, przed tokenami odpowiedzi. W grok-4.20-0309-reasoning rozumowanie pozostaje wewnętrzne i nie jest strumieniowane: w strumieniu pojawia się tylko finalna odpowiedź. Godny uwagi wyjątek: w API Responses, grok-4.7 strumieniuje podsumowanie swojego rozumowania w zdarzeniach response.reasoning_summary_text.delta, które możesz wyświetlić przed odpowiedzią.

Historyczny przykład z grok-3-mini:

stream = client.chat.completions.create(
    model="grok-4.20-0309-reasoning",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
    reasoning_effort="high",
    stream=True
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
        print(f"[Reasoning] {delta.reasoning_content}", end="")
    elif delta.content:
        print(f"[Response] {delta.content}", end="")

Kluczowe wnioski

  • Przydziel co najmniej 900 sekund na żądanie (3600 w przykładach z przewodnika Reasoning) i preferuj strumieniowanie
  • Trzy parametry są zabronione: presencePenalty, frequencyPenalty oraz stop
  • Czyść parametry podczas migracji z modeli klasycznych
  • Używaj max_completion_tokens zamiast max_tokens
  • Strumieniowanie działa, ale zachowanie różni się w zależności od modelu