Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Prestaties in productie

Les 11 van 14 Bijgewerkt op 29 juli 2026 Gevorderd
Op deze pagina
  1. Voorbij cache: algehele prestaties
  2. Streaming: tijd besparen zonder daadwerkelijk tijd te besparen
  3. Uw model kiezen voor latentie
  4. Fouten afhandelen zonder het erger te maken
  5. Time-outs en veerkracht
  6. Wat u moet instrumenteren
  7. Belangrijkste punten

Voorbij cache: algehele prestaties

Cache verlaagt de kosten, maar een succesvolle productie-integratie hangt van meer af dan alleen de rekening: door de gebruiker waargenomen latentie, aanhoudende doorvoer, betrouwbaarheid bij tijdelijke fouten en het vermogen om verslechtering te diagnosticeren. Een applicatie die weinig kost maar pas na 12 seconden reageert of één op de vijftig keer faalt, is niet performant. Deze les behandelt de vier dimensies die ertoe doen zodra u de kosten onder controle hebt.

Streaming: tijd besparen zonder daadwerkelijk tijd te besparen

Voor elke interface waarbij een mens op een antwoord wacht, verandert SSE-streaming (Server-Sent Events) de perceptie radicaal. Zonder streaming staart de gebruiker naar een cursor terwijl het model 500 tokens genereert; met streaming verschijnen de eerste woorden na een paar honderd milliseconden en begint het lezen tijdens het genereren. De totale tijd blijft gelijk, maar de waargenomen tijd wordt met een factor meerdere verkleind.

import requests
import json

def appel_streaming(messages, model="grok-4.20"):
    reponse = requests.post(
        "https://api.x.ai/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        },
        json={
            "model": model,
            "messages": messages,
            "stream": True
        },
        stream=True
    )

    for ligne in reponse.iter_lines():
        if ligne and ligne.startswith(b"data: "):
            donnees = ligne[6:]
            if donnees == b"[DONE]":
                break
            chunk = json.loads(donnees)
            token = chunk["choices"][0]["delta"].get("content", "")
            yield token

De parameter stream: True verandert niets aan het aantal gefactureerde tokens of hun tarief. Wat u verbetert, is de TTFT – de time to first token. Merk op dat de functie een generator is: deze geeft controle token voor token terug, zodat u direct naar de HTTP-respons van uw server kunt schrijven zonder de volledige generatie in het geheugen te houden.

Uw model kiezen voor latentie

De tweede hefboom voor latentie is de modelkeuze, en deze hangt voornamelijk af van de redeneerinspanning. Een redeneermodel produceert onzichtbare redeneertokens voordat het zijn antwoord opstelt: de kwaliteit stijgt, maar de vertraging ook. Aan de uitersten is grok-build-0.1 het snelste in de catalogus, waardoor het geschikt is voor real-time toepassingen zoals classificatie tijdens het uitvoeren of automatisch aanvullen; grok-4.20-0309 in de niet-redenerende variant en grok-4.3 bieden een redelijk compromis tussen kwaliteit en snelheid; grok-4.5 met diepgaand redeneren bevindt zich aan het andere uiteinde en is gereserveerd voor taken die dit echt vereisen.

Het praktische gevolg is dat u geen model kiest voor een applicatie, maar voor een stap. Een veelvoorkomend patroon is om een snelle initiële oproep te laten beslissen: is dit verzoek triviaal, ambigu of complex? Vervolgens stuurt u alleen het deel van de gevallen dat dit rechtvaardigt naar een redeneermodel. Zo verkleint u zowel de gemiddelde latentie als de gemiddelde kosten zonder moeilijke gevallen te benadelen.

Fouten afhandelen zonder het erger te maken

De code 429 die in les 3 aan bod kwam, is niet de enige die u zult tegenkomen. Het cruciale onderscheid ligt tussen fouten die een nieuwe poging verdienen en fouten waarbij opnieuw proberen alleen onnodig verkeer toevoegt.

CodeAardActie
429 Too Many RequestsHerstelbaarExponentiële backoff (les 3)
500 Internal Server ErrorHerstelbaarOpnieuw proberen met backoff; fout is serverzijde
502 / 503 Service UnavailableHerstelbaarOpnieuw proberen na enkele seconden
400 Bad RequestDefinitiefMisvormd verzoek; pas de payload aan
401 UnauthorizedDefinitiefOngeldige of verlopen API-sleutel
413 Payload Too LargeDefinitiefPrompt overschrijdt contextlimiet

U kunt deze regel in drie regels code vatten, en het loont de moeite om deze in een aparte functie onder te brengen in plaats van overal if-statements te verspreiden:

def classifier_erreur(status_code):
    recuperable = {429, 500, 502, 503}
    return status_code in recuperable

Time-outs en veerkracht

Een slecht ingestelde time-out creëert twee tegenovergestelde problemen: te kort, en u laat verzoeken vallen die zouden zijn gelukt; te lang, en u blokkeert uw workers terwijl de wachtrij langer wordt. Stel er drie afzonderlijk in. De verbinding moet binnen 10 seconden tot stand komen; daarbeyond ligt het probleem bij het netwerk. Lezen in niet-streamingmodus schaalt met het model: 120 seconden voor een redeneermodel, 60 seconden voor grok-build-0.1. Bij streaming is de relevante drempel niet de totale duur, maar het interval tussen chunks, ingesteld op ongeveer 30 seconden.

Eén punt verdient echte voorzichtigheid: wanneer een time-out verloopt tijdens een lange generatie, start dan niet automatisch opnieuw. Het model heeft mogelijk al redeneertokens verbruikt waarvoor u een tweede keer betaalt, en niets garandeert dat het eerste verzoek niet serverzijde is gelukt. Een idempotentiemechanisme – een verzoeksleutel die u bewaart om een duplicaat te herkennen – of een expliciete hervatting werkt beter dan een blinde nieuwe poging.

Wat u moet instrumenteren

Vier metriekfamilies volstaan om de meeste incidenten te diagnosticeren.

MetriekWat het onthultDoel
TTFTWaargenomen initiële latentieMonitor per model
SuccespercentageBetrouwbaarheid integratieGroter dan 99,5%
Cache-percentageKwaliteit promptstructuurGroter dan 50%
Kosten per verzoekBudgetafwijking, voortschrijdend gemiddeldeStabiel in de tijd

Voeg latentie bij het 95e percentiel toe. Het gemiddelde maskeert altijd extreme gevallen, en dat zijn precies de gevallen die supporttickets opleveren: een P95 van 8 seconden betekent dat één op de twintig gebruikers 8 seconden wacht, wat geen enkel gemiddelde van 1,2 seconde zou onthullen.

Belangrijkste punten

  • SSE-streaming vermindert de waargenomen latentie zonder de kosten te beïnvloeden
  • Kies een snel model voor real-time toepassingen en een redeneermodel voor kwaliteit
  • Onderscheid herstelbare fouten (429, 500, 502/503) van definitieve fouten (400, 401)
  • Configureer time-outs afgestemd op het gebruikte model
  • Monitor TTFT, succespercentage, cache-percentage en gemiddelde kosten per verzoek