Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Time-out, verboden parameters en configuratie

Les 11 van 12 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Configureer uw reasoning-verzoeken correct
  2. Time-out: minimaal 900 seconden
  3. Verboden parameters bij reasoning-modellen
  4. Fouten met betrekking tot parameters afhandelen
  5. Streaming met reasoning-modellen
  6. Belangrijkste punten

Bijgewerkt op 3 november 2026. Gebaseerd op de best practices van xAI en de Reasoning-gids: de aanbevolen wachttijd is minimaal 900 seconden (3.600 in voorbeelden), niet “minimaal 3.600 seconden”; de lijst met reasoning-modellen omvat grok-4.6 en grok-4.7; grok-4.7 streamt een samenvatting van zijn redenering; rechtvaardigingen voor verboden parameters, die ontbreken in de documentatie, zijn verwijderd. Bronnen: Best practices · Reasoning.

Configureer uw reasoning-verzoeken correct

Reasoning-modellen hebben specifieke beperkingen waar klassieke modellen geen last van hebben. Het negeren van deze beperkingen kan leiden tot stille fouten, onverwachte time-outs of afgekapte antwoorden. Deze les behandelt de essentiële configuratieparameters.

Time-out: minimaal 900 seconden

De best practices van xAI vereisen minimaal 900 seconden per verzoek, en 1.800 seconden of meer voor lange evaluaties; de voorbeelden in de Reasoning-gids stellen de vertraging zelfs in op 3.600 seconden (1 uur). Deze getallen lijken misschien hoog, maar ze weerspiegelen de realiteit: diepgaand redeneren over een complex probleem kan enkele minuten duren. xAI raadt ook aan om streaming te verkiezen, waardoor de verbinding actief blijft tijdens lange generaties.

Waarom zo’n lange time-out?

Wanneer een reasoning-model een moeilijk probleem verwerkt (wiskundig bewijs, complexe code-analyse, redenering in meerdere stappen), genereert het mogelijk duizenden interne reasoning-tokens voordat het zijn antwoord formuleert. Dit proces is lineair en kan niet worden gepara llelliseerd.

Time-outconfiguratie

import httpx
from openai import OpenAI

# Configuratie met hoge time-out
client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0, connect=10.0)
)

In JavaScript met de OpenAI SDK:

import OpenAI from 'openai';

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

Time-out van de webserver

Als uw applicatie achter een reverse proxy staat (nginx, Apache), configureer dan ook de server-side time-out:

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

Verboden parameters bij reasoning-modellen

Drie parameters die vaak worden gebruikt bij klassieke modellen, kunnen niet worden verzonden naar xAI reasoning-modellen: volgens de Reasoning-gids geeft een verzoek dat deze bevat een foutmelding. De documentatie geeft geen reden voor deze verboden; onthoud gewoon de regel.

presencePenalty

// FOUT bij reasoning-modellen
{
  "model": "grok-4.20-0309-reasoning",
  "presence_penalty": 0.5,  // Verboden!
  "messages": [...]
}

presencePenalty straft tokens af die al in het antwoord zijn verschenen om diversiteit aan te moedigen.

frequencyPenalty

// FOUT bij reasoning-modellen
{
  "model": "grok-4.20-0309-reasoning",
  "frequency_penalty": 0.3,  // Verboden!
  "messages": [...]
}

frequencyPenalty straft tokens evenredig af met de frequentie waarmee ze voorkomen.

stop

// FOUT bij reasoning-modellen
{
  "model": "grok-4.20-0309-reasoning",
  "stop": ["\n\n"],  // Verboden!
  "messages": [...]
}

De parameter stop stopt de generatie wanneer een specifieke reeks verschijnt. Gebruik in plaats daarvan max_completion_tokens om de lengte van het antwoord te begrenzen; dit limiteert alleen het zichtbare antwoord, samen met een formatinstructie in de prompt.

Fouten met betrekking tot parameters afhandelen

Wanneer u bestaande code migreert naar een reasoning-model, verwijdert u niet-ondersteunde parameters:

def prepare_params(model, base_params):
    """Schoont parameters op voor reasoning-modellen."""
    reasoning_models = [
        # huidige bereik
        "grok-4.7", "grok-4.6", "grok-4.5", "grok-4.20-0309-reasoning",
        # historische identifiers, nog steeds aanwezig in bestaande code
        "grok-3-mini", "grok-4-fast-reasoning",
    ]

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

    if model in reasoning_models:
        # Verwijder verboden parameters
        for forbidden in ["presence_penalty", "frequency_penalty", "stop"]:
            params.pop(forbidden, None)

        # Vervang max_tokens door max_completion_tokens
        if "max_tokens" in params:
            params["max_completion_tokens"] = params.pop("max_tokens")

    return params

Streaming met reasoning-modellen

Streaming werkt met reasoning-modellen, maar het gedrag hangt af van de generatie: bij grok-3-mini (vorige generatie) verscheen reasoning_content duidelijk in de stream, vóór de antwoordtokens. Bij grok-4.20-0309-reasoning blijft de redenering intern en wordt deze niet gestreamd: alleen het uiteindelijke antwoord arriveert in de stream. Opmerkelijke uitzondering: bij de Responses API streamt grok-4.7 een samenvatting van zijn redenering, in response.reasoning_summary_text.delta-events die u kunt weergeven vóór het antwoord.

Historisch voorbeeld met 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="")

Belangrijkste punten

  • Sta minimaal 900 seconden per verzoek toe (3.600 in voorbeelden uit de Reasoning-gids) en geef de voorkeur aan streaming
  • Drie parameters zijn verboden: presencePenalty, frequencyPenalty en stop
  • Schoon parameters op bij migratie van klassieke modellen
  • Gebruik max_completion_tokens in plaats van max_tokens
  • Streaming werkt, maar het gedrag verschilt per model