Salt la conținutul principal
Română— Alege o limbă
Meniu

Performanță în producție

Lecția 11 din 14 Actualizată 29 iulie 2026 Avansat
Pe această pagină
  1. Dincolo de cache: performanța globală
  2. Streaming: economisirea timpului fără a-l economisi realmente
  3. Alegerea modelului pentru latență
  4. Gestionarea erorilor fără a agrava situația
  5. Timeout-uri și reziliență
  6. Ce să instrumentați
  7. Puncte cheie

Dincolo de cache: performanța globală

Cache-ul reduce costurile, dar integrarea în producție depinde de mai mult decât simpla factură: latența percepută de utilizator, throughput-ul susținut, fiabilitatea în fața erorilor tranzitorii și capacitatea de a diagnostica degradările. O aplicație ieftină, care răspunde în 12 secunde sau eșuează o dată din 50, nu este performantă. Această lecție acoperă cele patru dimensiuni esențiale odată ce ați stăpânit costul.

Streaming: economisirea timpului fără a-l economisi realmente

Pentru orice interfață în care un om așteaptă un răspuns, streaming-ul prin SSE (Server-Sent Events) schimbă radical percepția. Fără el, utilizatorul se uită la cursor în timp ce modelul generează 500 de tokeni; cu el, primele cuvinte apar după câteva sute de milisecunde, iar citirea începe în timpul generării. Timpul total rămâne același, dar timpul perceput se reduce de câteva ori.

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

Parametrul stream: True nu modifică nici numărul de tokeni facturați, nici tariful acestora. Ce îmbunătățiți este TTFT – time to first token (timpul până la primul token). Rețineți că funcția este un generator: cedează controlul token cu token, permițându-vă să scrieți direct în răspunsul HTTP al serverului fără a menține întreaga generare în memorie.

Alegerea modelului pentru latență

A doua pârghie de latență este alegerea modelului, care depinde în principal de efortul de raționament. Un model de raționament produce tokeni de raționament invizibili înainte de a-și schița răspunsul: calitatea crește, dar și întârzierea. La extreme, grok-build-0.1 este cel mai rapid din catalog, fiind potrivit pentru utilizări în timp real, cum ar fi clasificarea din zbor sau autocompletarea; grok-4.20-0309 în varianta non-raționament și grok-4.3 oferă un compromis rezonabil între calitate și viteză; grok-4.5 cu raționament profund se situează la celălalt capăt, rezervat sarcinilor care îl cer cu adevărat.

Consecința practică este că nu alegeți un model pentru o aplicație întreagă, ci pentru o etapă specifică. Un model comun constă într-un apel inițial rapid care decide: este această cerere trivială, ambiguă sau complexă? Apoi trimiteți către un model de raționament doar fracțiunea de cazuri care o justifică. Divideți astfel atât latența medie, cât și costul mediu, fără a degrada cazurile dificile.

Gestionarea erorilor fără a agrava situația

Codul 429 abordat în Lecția 3 nu este singurul pe care îl veți întâlni. Distincția cheie constă între erorile care merită o reîncercare și cele pentru care reîncercarea adaugă doar trafic inutil.

CodNaturăAcțiune
429 Too Many RequestsRecuperabilăBackoff exponențial (Lecția 3)
500 Internal Server ErrorRecuperabilăReîncercare cu backoff; eroare latoare server
502 / 503 Service UnavailableRecuperabilăReîncercare după câteva secunde
400 Bad RequestFinalăCerere malformată; corectați payload-ul
401 UnauthorizedFinalăCheie API invalidă sau expirată
413 Payload Too LargeFinalăPromptul depășește limita de context

Puteți codifica această regulă în trei linii și merită să o izolați într-o funcție, în loc să împrăștiați instrucțiuni if peste tot:

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

Timeout-uri și reziliență

Un timeout setat necorespunzător creează două probleme opuse: dacă este prea scurt, abandonează cereri care ar fi reușit; dacă este prea lung, blochează workerii în timp ce coada se lungeste. Setați trei valori distincte. Conexiunea trebuie stabilită în 10 secunde; dincolo de acest prag, problema este de rețea. Citirea în mod non-streaming scalează cu modelul: 120 de secunde pentru un model de raționament, 60 de secunde pentru grok-build-0.1. În streaming, pragul relevant nu este durata totală, ci intervalul dintre chunk-uri, setat la aproximativ 30 de secunde.

Un punct necesită o atenție deosebită: când un timeout expiră în timpul unei generări lungi, nu reporniți automat. Modelul poate fi consumat deja tokeni de raționament pentru care veți plăti din nou, iar nimic nu garantează că prima cerere nu a reușit latoare server. Un mecanism de idempotență – o cheie de cerere pe care o păstrați pentru a recunoaște un duplicat – sau o reluare explicită funcționează mai bine decât o reîncercare oarbă.

Ce să instrumentați

Patru familii de metrici sunt suficiente pentru a diagnostica majoritatea incidentelor.

MetricăCe dezvăluieȚintă
TTFTLatența inițială perceputăMonitorizare per model
Rata de succesFiabilitatea integrăriiMai mare de 99,5%
Rata de cacheCalitatea structurii promptuluiMai mare de 50%
Cost per cerereDeriva bugetară, medie mobilăStabil în timp

Adăugați latența la percentila 95. Media maschează întotdeauna cazurile extreme, iar acelea sunt cele care declanșează tichete de suport: un P95 de 8 secunde înseamnă că un utilizator din 20 așteaptă 8 secunde, lucru pe care nicio medie de 1,2 secunde nu l-ar revela.

Puncte cheie

  • Streaming-ul SSE reduce latența percepută fără a afecta costul
  • Alegeți un model rapid pentru timp real și un model de raționament pentru calitate
  • Distingeți erorile recuperabile (429, 500, 502/503) de erorile finale (400, 401)
  • Configurați timeout-uri adaptate modelului utilizat
  • Monitorizați TTFT, rata de succes, rata de cache și costul mediu per cerere