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

Cele mai bune practici și pașii următori

Lecția 14 din 14 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Recapitularea cursului
  2. Securizarea cheilor API
  3. Gestionarea erorilor
  4. Conviețuirea cu limitele de rată
  5. Controlul costurilor
  6. Observarea a ceea ce se întâmplă
  7. Ce urmează
  8. Puncte cheie
  9. Testați-vă cunoștințele

Recapitularea cursului

Ați parcurs toate elementele fundamentale ale utilizării API-ului Mistral: crearea contului, gestionarea cheilor, selectarea planului, instalarea SDK-urilor pentru Python și TypeScript, streaming-ul, conversațiile multi-tur, migrarea V1/V2 și implementarea pe principalii furnizori de cloud. Ce urmează nu mai ține de învățarea API-ului în sine, ci de diferența dintre un script care funcționează și o aplicație care rezistă în producție.

Securizarea cheilor API

Aceasta este cea mai frecventă cauză a incidentelor în producție, aproape întotdeauna din același motiv: o cheie inclusă direct în cod „doar pentru testare“ și apoi uitată într-un commit. O cheie API nu trebuie să apară niciodată în codul sursă; locul ei este într-o variabilă de mediu sau, și mai bine, într-un manager de secrete precum AWS Secrets Manager, Azure Key Vault sau HashiCorp Vault.

Separarea vine imediat după. Utilizați o cheie distinctă pentru fiecare mediu—dezvoltare, staging, producție—pentru a preveni situația în care un test eșuat consumă cota serviciului live. Folosiți o cheie per aplicație pentru a limita raza de impact: dacă o cheie este compromisă, revocați doar pe cea aferentă aplicației afectate. Planificați rotația la fiecare 90 de zile în producție și configurați alerte în Consola Mistral pentru utilizări anormale: o cheie compromisă se manifestă inițial printr-o curbă de utilizare care crește brusc fără motiv.

Gestionarea erorilor

În producție, orice apel API poate eșua. Întrebarea nu este dacă se va întâmpla, ci când. Patru coduri de status acoperă majoritatea situațiilor pe care le veți întâlni:

CodSemnificațieAcțiune
401 UnauthorizedCheie API invalidă sau expiratăVerificați variabila de mediu
429 Too Many RequestsLimita de rată atinsăReîncercați cu backoff exponențial
500 Internal Server ErrorProblemă din partea MistralReîncercare automată după câteva secunde
503 Service UnavailableSupraîncărcare temporarăReîncercare cu backoff

Distincția contează: nu remediați niciodată o eroare 401 prin reîncercare; configurația dumneavoastră este cea defectuoasă. Celelalte trei sunt tranzitorii, iar răspunsul corect este reîncercarea cu întârzieri progresiv mai lungi—o secundă, apoi două, apoi patru. Reîncercarea imediată într-o buclă la o eroare 429 nu face decât să agraveze saturația pe care o experimentați.

Iată modelul în Python: maximum trei încercări, propagarea excepției dacă ultima eșuează și dublarea timpului de așteptare după fiecare eșec folosind 2 ** attempt.

import time
import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

def call_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.complete(
                model="mistral-small-latest",
                messages=messages,
            )
            return response
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            waitTime = 2 ** attempt  # 1s, 2s, 4s
            print(f"Error: {e}. Retrying in {waitTime}s...")
            time.sleep(waitTime)

Traducerea în TypeScript urmează exact aceeași logică, cu excepția faptului că timpul de așteptare este exprimat în milisecunde, iar pauza este construită cu un promise și setTimeout:

async function callWithRetry(
  client: Mistral,
  messages: Array<{ role: string; content: string }>,
  maxRetries = 3
) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.chat.complete({
        model: 'mistral-small-latest',
        messages,
      });
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
      const waitTime = Math.pow(2, attempt) * 1000;
      console.log(`Error. Retrying in ${waitTime}ms...`);
      await new Promise((r) => setTimeout(r, waitTime));
    }
  }
}

Conviețuirea cu limitele de rată

Limitele de rată protejează API-ul de abuzuri, iar logica de reîncercare singură nu este suficientă pentru a le respecta: ea repară lucrurile doar după fapt. Verificați limitele în Consola Mistral—cereri pe secundă, tokeni pe minut—apoi implementați limitarea (throttling) la nivel de client pentru a preveni depășirea acestora. Cererile în exces trebuie puse în coadă, nu eliminate: un utilizator preferă să aștepte două secunde decât să primească o eroare.

Când apare o eroare 429 în ciuda eforturilor dumneavoastră, răspunsul include un antet Retry-After care indică momentul când să reîncercați; citirea acestuia este mai bună decât ghicirea. Iar dacă utilizarea legitimă depășește constant limitele planului Scale, solicitați o creștere a cotei prin suport, în loc să multiplicați soluțiile ocolitoare.

Controlul costurilor

Prima pârghie, și de departe cea mai eficientă, este selecția modelului. Clasificarea, extragerea câmpurilor sau reformularea nu necesită un raționament elaborat: mistral-small-latest le gestionează foarte bine. Rezervați mistral-large-latest pentru sarcinile unde calitatea raționamentului face diferența—analiză, sinteză complexă, scriere de lungă durată—și utilizați codestral-latest pentru generarea de cod. Nu plătiți pentru Mistral Large 3 să facă ceea ce Mistral Small poate face la fel de bine: la volum de producție, diferența se măsoară în ordine de mărime.

A doua pârghie privește numărul de tokeni schimbați. Un prompt concis, curățat de instrucțiuni redundante acumulate în timpul iterațiilor, costă mai puțin la fiecare apel. În conversațiile multi-tur, trimiteți doar mesajele necesare: reluarea unui istoric de treizeci de schimburi pentru fiecare întrebare umflă factura foarte repede. Ajustați max_tokens la ceea ce anticipați realmente și stocați în cache răspunsurile recurente—cea mai ieftină cerere este cea pe care nu o faceți.

Observarea a ceea ce se întâmplă

În producție, înregistrați în jurnal (log) fiecare apel. Fără aceasta, nu veți ști de ce un răspuns a fost trunchiat sau care utilizare explică factura lunii. Funcția de mai jos împachetează apelul cu două urme: ce iese, apoi ce intră, inclusiv numărul total de tokeni și motivul opririi.

import logging

logger = logging.getLogger("mistral")

def logged_call(client, messages, model="mistral-small-latest"):
    logger.info(f"API Call — model: {model}, messages: {len(messages)}")

    response = client.chat.complete(model=model, messages=messages)

    logger.info(
        f"Response — tokens: {response.usage.total_tokens}, "
        f"finish: {response.choices[0].finish_reason}"
    )

    return response

Aceste două linii răspund majorității întrebărilor pe care vi le veți pune mai târziu. Un finish_reason care semnalează o limită de lungime explică un răspuns întrerupt la mijloc; o medie derivantă a numărului de tokeni relevă un prompt care a crescut sau un istoric care nu a fost curățat corespunzător.

Ce urmează

Cu fundamentele puse la punct, se deschid mai multe căi. Apelarea funcțiilor (Function calling) permite modelului să invoce propriile dumneavoastră funcții și API-uri. RAG (Retrieval-Augmented Generation) îmbogățește răspunsurile cu datele interne, în timp ce embedding-urile, care transformă textul în vectori, constituie blocul de bază al căutării semantice. Fine-tuning-ul adaptează un model la domeniul dumneavoastră atunci când prompting-ul nu mai este suficient, agenții înlănțuie apeluri pentru a construi sisteme autonome, iar evaluarea vă oferă un mod de a măsura calitatea răspunsurilor în loc să o estimați vizual.

Fiecare dintre aceste subiecte are cursuri dedicate în catalogul Corsen Academy.

Puncte cheie

  • Securizați cheile API cu un manager de secrete și rotație regulată
  • Implementați sistematic reîncercarea cu backoff exponențial
  • Alegeți cel mai ușor model capabil să gestioneze sarcina dumneavoastră
  • Înregistrați în jurnal fiecare apel API pentru diagnostic și optimizarea costurilor
  • API-ul Mistral este fundația dumneavoastră—pașii următori (apelarea funcțiilor, RAG, agenți) se construiesc pe tot ce ați învățat

Testați-vă cunoștințele

Consolă, SDK, furnizori de cloud: este fundația API pusă la punct?

1. Ce reflexe trebuie să aveți pentru cheia API imediat după crearea ei?

Răspuns: Stocați-o în siguranță (este afișată o singură dată), țineți-o departe de cod prin variabile de mediu, folosiți o cheie per mediu și rotiți-o în caz de dubiu.

2. Ce diferențiază planurile Experiment și Scale?

Răspuns: Cotele și prețurile: Experiment pentru descoperire și prototipare, Scale pentru producție—verificați limitele în consolă înainte de dimensionare.

3. Care este scheletul unui prim apel în Python?

Răspuns: Client inițializat cu cheia, apel chat cu modelul și lista de mesaje, citirea conținutului răspunsului—iar streaming-ul este activat pentru afișare progresivă.

4. Cum gestionați o conversație multi-tur prin API?

Răspuns: Prin menținerea istoricului de către dumneavoastră: fiecare cerere trimite lista completă de mesaje (utilizator și asistent)—API-ul este fără stare (stateless).

5. Ce trebuie să știți despre implementările prin Azure, Vertex sau Bedrock?

Răspuns: Modelele Mistral sunt disponibile acolo cu autentificarea și facturarea cloud-ului ales—aceeași familie de modele, punct de acces diferit, util pentru constrângerile de infrastructură.

Cheie securizată, istoric gestionat, plan adaptat: cele mai bune practici finale transformă această fundație într-o bază de producție.