Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Legjobb gyakorlatok és következő lépések

14. lecke 14 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. A kurzus összefoglalása
  2. Az API-kulcsok biztonsága
  3. Hibakezelés
  4. A sebességkorlátok kezelése
  5. Költségek kontrollálása
  6. A történések megfigyelése
  7. Mi következik?
  8. Főbb megállapítások
  9. Teszteld a tudásod!

A kurzus összefoglalása

Végigvetted a Mistral API használatának összes alapvető elemét: a fiók létrehozását, a kulcsok kezelését, az előfizetési csomag kiválasztását, a Python és TypeScript SDK-k telepítését, az adatfolyam-alapú válaszadást (streaming), a többfordulós beszélgetéseket, a V1/V2 migrációt és a főbb felhőszolgáltatóknál történő üzembe helyezést. Ami ezután következik, az már nem magáról az API megtanulásáról szól, hanem arról a különbségről, ami egy működő szkript és egy éles környezetben is megálló alkalmazás között van.

Az API-kulcsok biztonsága

Ez a leggyakoribb oka az éles környezetben fellépő incidenseeknek, szinte mindig ugyanazon okból: egy kulcsot „csak tesztelés céljából“ keménykódolnak, majd elfelejtenek egy commitban. Az API-kulcs soha nem szerepelhet a forráskódban; a helye egy környezeti változóban, vagy még jobb esetben egy titokkezelőben van, mint például az AWS Secrets Manager, az Azure Key Vault vagy a HashiCorp Vault.

A szétválasztás a következő lépés. Használj külön kulcsot minden környezethez – fejlesztés, tesztelés (staging), élesítés (production) –, hogy egy sikertelen teszt ne eméssze fel az élő szolgáltatásod kvótáját. Alkalmazzon külön kulcsot alkalmazásonként a károk begrenyezése érdekében: ha egy kulcs kiszivárog, csak az érintett alkalmazásét kell visszavonnod. Tervezd meg a kulcsok cseréjét 90 naponta éles környezetben, és állíts be riasztásokat a Mistral Console-ban rendellenes használat esetén: egy kompromittált kulcs először egy indokolatlanul megugró használati görbében mutatkozik meg.

Hibakezelés

Éles környezetben minden API-hívás meghiúsulhat. A kérdés nem az, hogy megtörténik-e, hanem az, hogy mikor. Négy státuszkód lefedi az esetek többségét, amivel találkozhatsz:

KódJelentésTeendő
401 UnauthorizedÉrvénytelen vagy lejárt API-kulcsEllenőrizd a környezeti változódat
429 Too Many RequestsElérted a sebességkorlátotÚjrapróbálkozás exponenciális háttéridővel
500 Internal Server ErrorHiba a Mistral oldalánAutomatikus újrapróbálkozás néhány másodperc múlva
503 Service UnavailableIdeiglenes túlterheltségÚjrapróbálkozás háttéridővel

A különbségtétel fontos: soha nem oldasz meg egy 401-es hibát újrapróbálkozással; itt a konfigurációddal van a baj. A másik három hiba átmeneti jellegű, és a helyes válasz az, hogy egyre hosszabbodó késleltetéssel próbálkozol újra – egy másodperc, majd kettő, majd négy. Ha egy 429-es hibára azonnal, ciklusban próbálsz újra, azzal csak rontod a tapasztalt telítettséget.

Íme a minta Pythonban: maximum három próbálkozás, hiba esetén dobd el a kivételt, ha az utolsó is sikertelen, és minden hiba után duplázd meg a várakozási időt a 2 ** attempt képlettel.

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)

A TypeScript változat pontosan ugyanazt a logikát követi, kivéve, hogy a várakozási időt milliszekundumban adjuk meg, és a szünetet egy promise és a setTimeout segítségével oldjuk meg:

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));
    }
  }
}

A sebességkorlátok kezelése

A sebességkorlátok (rate limits) védik az API-t a visszaélésektől, és az újrapróbálkozó logika önmagában nem elég a betartásukhoz: az csak utólag orvosolja a problémát. Ellenőrizd a korlátaidat a Mistral Console-ban – másodpercenkénti kérések, percenkénti tokenek –, majd implementálj kliens oldali fojtást (throttling), hogy megelőzd a túllépést. A felesleges kéréseket sorba kell állítani, nem eldobni: egy felhasználó inkább vár két másodpercet, mintsem hibát kapjon.

Ha a legjobb szándékaid ellenére mégis fellép egy 429-es hiba, a válasz tartalmaz egy Retry-After fejlécet, amely jelzi, mikor érdemes újra próbálkozni; ezt kiolvasni jobb, mint találgatni. És ha a legitim használatod tartósan meghaladja a Scale csomag korlátait, kérj kvótanövelést a támogatási csapaton keresztül, ahelyett, hogy kerülőutakat szaporítanál.

Költségek kontrollálása

Az első és messze leghatékonyabb kar a modell kiválasztása. Az osztályozás, az adatmezők kinyerése vagy az átfogalmazás nem igényel bonyolult következtetést: a mistral-small-latest ezeket nagyon jól kezeli. A mistral-large-latest modellt olyan feladatokra tartalékold, ahol a következtetés minősége döntő – elemzés, komplex szintézis, hosszú szövegek írása –, a kódgeneráláshoz pedig használd a codestral-latest modellt. Ne fizess a Mistral Large 3-ért olyasmiért, amit a Mistral Small ugyanolyan jól megcsinál: éles volumen esetén a különbség nagyságrendekben mérhető.

A második kar a cserélt tokenek számát érinti. Egy tömör prompt, amely mentes az iterációk során felhalmozódott felesleges utasításoktól, minden hívásnál kevesebbe kerül. Többfordulós beszélgetések során csak a szükséges üzeneteket küldd el: ha minden kérdésre harminc váltás történetét lejátszod, az nagyon gyorsan megdrágítja a számlát. Állítsd be a max_tokens értéket arra, amire ténylegesen számítasz, és gyorsítótárazd az ismétlődő válaszokat – a legolcsóbb kérés az, amit meg sem ejtesz.

A történések megfigyelése

Éles környezetben naplózz minden hívást. Enélkül nem fogod tudni, miért lett levágva egy válasz, vagy melyik használat magyarázza a havi számlát. Az alábbi függvény burkolja a hívást két nyomkövetéssel: mi megy ki, majd mi jön vissza, beleértve a teljes tokenszámot és a leállási okot is.

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

Ez a két sor megválaszolja a kérdések többségét, amit később felteszel majd magadnak. Egy hosszúsági korlátot jelző finish_reason megmagyarázza a félbeszakadt választ; egy eltolódó átlagos tokenszám pedig arra utal, hogy a prompt túlnőtt, vagy a történetet nem tisztították meg megfelelően.

Mi következik?

Az alapok lerakásával több út is megnyílik előtted. A függvényhívás (function calling) lehetővé teszi, hogy a modell a saját függvényeidet és API-jaidat hívja meg. A RAG (Retrieval-Augmented Generation) a belső adataiddal gazdagítja a válaszokat, míg a beágyazások (embeddings), amelyek szöveget vektorokká alakítanak, a szemantikus keresés építőkövei. A finomhangolás (fine-tuning) a modellt a te domainedhez igazítja, amikor a promptolás már nem elég, az ágens rendszerek hívásláncokat építenek autonóm rendszerek létrehozásához, az értékelés (evaluation) pedig módot ad a válaszminőség mérésére a szemrevételezéses becslés helyett.

Ezekhez a témákhoz külön kurzusok tartoznak a Corsen Academy katalógusában.

Főbb megállapítások

  • Biztosítsd az API-kulcsaidat titokkezelővel és rendszeres cserével
  • Implementáld szisztematikusan az exponenciális háttéridővel történő újrapróbálkozást
  • Válaszd a feladatod ellátására képes legkönnyebb modellt
  • Naplózz minden API-hívást a diagnosztika és a költséghatékonyság érdekében
  • A Mistral API az alapod – a következő lépések (függvényhívás, RAG, ágensek) erre építenek

Teszteld a tudásod!

Console, SDK, felhőszolgáltatók: készen áll az API alapozás?

1. Milyen reflexeknek kell működésbe lépniük az API-kulcs létrehozásakor?

Válasz: Tárold biztonságosan (csak egyszer jelenik meg), tartsd távol a kódtól környezeti változók használatával, használj külön kulcsot környezetenként, és cseréld le, ha kétséged merül fel.

2. Mi különbözteti meg az Experiment és a Scale csomagokat?

Válasz: A kvóták és az árazás: az Experiment a felfedezésre és prototípuskészítésre való, a Scale az éles környezetre – a méretezés előtt ellenőrizd a korlátaidat a konzolban.

3. Mi az első Python hívás váza?

Válasz: A kliens inicializálása a kulccsal, a chat hívás a modellel és az üzenetlistával, a válasz tartalmának kiolvasása – és a streaming engedélyezése a fokozatos megjelenítéshez.

4. Hogyan kezelsz egy többfordulós beszélgetést az API-n keresztül?

Válasz: A történetet neked kell karbantartanod: minden kérés elküldi az üzenetek teljes listáját (felhasználó és asszisztens) – az API állapot nélküli (stateless).

5. Mit kell tudnod az Azure, Vertex vagy Bedrock alapú üzembe helyezésekről?

Válasz: A Mistral modellek ott is elérhetők a választott felhő hitelesítésével és számlázásával – ugyanaz a modellcsalád, más hozzáférési pont, ami infrastruktúrális kényszerek esetén hasznos.

Kulcs biztosítva, történet kezelve, csomag testreszabva: a végső legjobb gyakorlatok ezt az alapot éles környezeti bázissá alakítják.