Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Osvedčené postupy pre nasadenie do produkcie

Lekcia 16 z 16 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Od prototypu k nasadeniu
  2. Autentifikácia a verzovanie modelov
  3. Klient, ktorý zvláda incidenty
  4. Sleduj náklady v reálnom čase
  5. Validuj na oboch koncoch
  6. Udržuj kontextové okno
  7. Čo si z tohto kurzu odnášaš
  8. Kľúčové poznatky
  9. Otestuj si svoje vedomosti

Od prototypu k nasadeniu

Teraz ovládaš každý parameter API Chat Completions. Najnáročnejšia časť však ešte len príde: preklenutie priepasti medzi funkčným notebookom a službou, ktorú používatelia využívajú bez tvojej priamej intervencie. Táto záverečná lekcia zhrnie celý kurz do akčného kontrolného zoznamu pre produkciu a ukáže ti smer k nasledujúcim kurzom.

Autentifikácia a verzovanie modelov

Pred napísaním prvého riadku business logiky musíš urobiť dve kľúčové rozhodnutia. Prvé sa týka API kľúča: musí byť uložený v premennej prostredia, nikdy nie priamo v kóde. Overenie jeho existencie pri štarte aplikácie je lepšie než None, ktorá sa prenesie o tri vrstvy nižšie a vyústi do nezrozumiteľnej chybovej hlášky. Naplánuj si aj rotáciu kľúčov – ak chceš predísť výpadku služby, najprv vytvor nový kľúč, nasaď ho a až potom zruš ten starý.

import os

# VŽDY: API kľúč v premennej prostredia
api_key = os.getenv("MISTRAL_API_KEY")
assert api_key, "MISTRAL_API_KEY nie je definovaný"

# NIKDY: kľúč natvrdo v kóde
# api_key = "sk-abc123..."  # V PRODUKCII ZAKÁZANÉ

# VŽDY: pravidelná rotácia kľúčov
# Vytvor nový kľúč, nasaď ho a potom zruš starý

Druhé rozhodnutie sa týka identifikátora modelu. Vo vývojovom prostredí ti prípona -latest prináša vylepšenia bez námahy. V produkcii však tento alias znamená, že zmena verzie na strane poskytovateľa môže zmeniť správanie tvojej aplikácie bez varovania – napríklad v utorok ráno – a ty nebudeš mať v histórii commitov žiadnu stopu, ktorá by to vysvetľovala. Pripni konkrétnu verziu.

# VÝVOJ — najnovšia verzia
model = "mistral-large-latest"

# PRODUKCIA — pevná verzia pre reprodukovateľnosť
model = "mistral-large-2512"

# Prečo? Zmena "latest" môže bez varovania zmeniť
# správanie tvojej aplikácie.

Klient, ktorý zvláda incidenty

Srdcom produkčnej integrácie nie je samotné volanie API, ale všetko, čo ho obklopuje. Nižšie uvedená trieda spája tri zodpovednosti do jedného kontrolného bodu: opakovanie pokusu s exponenciálnym oneskorením pri chybe 429, krátka pauza pri chybách servera a okamžitá eskalácia chýb klienta, ktoré žiadne opakovanie nevyrieši. Zároveň normalizuje odpoveď do stabilného slovníka – obsah, finish_reason, využitie, model, ID – takže zvyšok tvojho kódu už nemusí závisieť od presnej štruktúry objektu vráteného SDK. Už len samotné logger.warning pri skrátení odpovede ospravedlňuje toto zapuzdrenie: je to jediný spôsob, ako zistiť, že nastavenie max_tokens je príliš prísne, skôr než si to všimnú používatelia.

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import time
import logging

logger = logging.getLogger(__name__)

class MistralClient:
    """Produkčný klient s opakovaním pokusov, časovým limitom a logovaním."""

    def __init__(self, api_key: str, max_retries: int = 3):
        self.client = Mistral(api_key=api_key)
        self.max_retries = max_retries

    def complete(self, messages: list, **kwargs) -> dict:
        for attempt in range(self.max_retries):
            try:
                response = self.client.chat.complete(
                    messages=messages,
                    **kwargs
                )

                result = {
                    "content": response.choices[0].message.content,
                    "finish_reason": response.choices[0].finish_reason,
                    "usage": {
                        "prompt": response.usage.prompt_tokens,
                        "completion": response.usage.completion_tokens,
                        "total": response.usage.total_tokens,
                    },
                    "model": response.model,
                    "id": response.id,
                }

                # Upozornenie, ak bola odpoveď skrátená
                if result["finish_reason"] == "length":
                    logger.warning(f"Odpoveď skrátená — req_id={response.id}")

                return result

            except SDKError as e:
                if e.status_code == 429:
                    wait = 2 ** attempt
                    logger.warning(f"Prekročený limit, opakovanie {attempt+1}/{self.max_retries} za {wait}s")
                    time.sleep(wait)
                elif e.status_code >= 500:
                    logger.error(f"Chyba servera {e.status_code}, opakovanie {attempt+1}")
                    time.sleep(1)
                else:
                    logger.error(f"Chyba klienta {e.status_code}: {e.message}")
                    raise

        raise Exception(f"Neúspešné po {self.max_retries} pokusoch")

Sleduj náklady v reálnom čase

Zisťovanie spotreby až z mesačného vyúčtovania je luxus, ktorý si málo tímov môže dovoliť. Nižšie uvedený sledovač zapisuje jeden riadok JSONL na každé volanie – časová pečiatka, model, vstupné a výstupné tokeny, finish_reason, ID požiadavky – a udržiava súčet za reláciu, ktorý môžeš kedykoľvek queryovať. Formát JSONL nie je detail: umožňuje agregáciu s akýmkoľvek analytickým nástrojom bez potreby ďalšieho parsovania a prítomnosť ID požiadavky ti umožňuje spojiť anomáliu v nákladoch s konkrétnym volaním.

import json
from datetime import datetime, timezone

class CostTracker:
    """Sledovanie nákladov na API v reálnom čase."""

    def __init__(self, log_path: str = "api_costs.jsonl"):
        self.log_path = log_path
        self.session_tokens = {"prompt": 0, "completion": 0}

    def log(self, response_data: dict):
        usage = response_data["usage"]
        self.session_tokens["prompt"] += usage["prompt"]
        self.session_tokens["completion"] += usage["completion"]

        entry = {
            "ts": datetime.now(timezone.utc).isoformat(),
            "model": response_data["model"],
            "prompt_tokens": usage["prompt"],
            "completion_tokens": usage["completion"],
            "finish_reason": response_data["finish_reason"],
            "id": response_data["id"],
        }

        with open(self.log_path, "a") as f:
            f.write(json.dumps(entry) + "\n")

    def report(self) -> str:
        total = self.session_tokens["prompt"] + self.session_tokens["completion"]
        return (
            f"Relácia — Prompt: {self.session_tokens['prompt']:,} | "
            f"Dokončenie: {self.session_tokens['completion']:,} | "
            f"Celkom: {total:,} tokenov"
        )

Validuj na oboch koncoch

Robustná aplikácia neverí ani tomu, čo ide dnu, ani tomu, čo vychádza von. Pri vstupe zamietni prázdne správy, obmedz dĺžku na 10 000 znakov, aby sa ti nešťastný copy-paste nestal zdrojom enormných nákladov, a odstráň riadiace znaky, ktoré narúšajú tokenizáciu. Pri výstupe nič nezamietaj, ale generuj upozornenia: potenciálne skrátená odpoveď, abnormálne krátka odpoveď pod 5 znakov alebo abnormálne dlhá odpoveď nad 50 000 znakov. Tieto tri signály zachytia väčšinu tichých zlyhaní.

def validate_input(user_message: str) -> str:
    """Validácia a čistenie vstupu od používateľa."""
    if not user_message or not user_message.strip():
        raise ValueError("Prázdna správa")

    if len(user_message) > 10_000:
        raise ValueError("Správa príliš dlhá (max 10 000 znakov)")

    # Vyčistenie riadiacich znakov
    cleaned = "".join(c for c in user_message if c.isprintable() or c in "\n\t")
    return cleaned.strip()

def validate_output(content: str, finish_reason: str) -> dict:
    """Validácia výstupu z API."""
    warnings = []

    if finish_reason == "length":
        warnings.append("Odpoveď potenciálne skrátená")

    if not content or len(content.strip()) < 5:
        warnings.append("Abnormálne krátka odpoveď")

    if len(content) > 50_000:
        warnings.append("Abnormálne dlhá odpoveď")

    return {"content": content, "warnings": warnings, "valid": len(warnings) == 0}

Udržuj kontextové okno

Posledný problém: pomalý posun pri dlhých konverzáciách. Funkcia nižšie odhaduje objem ako jeden token na štyri znaky vo francúzštine – hrubá aproximácia, ale dostatočná ako ochranný mechanizmus – a prepúšťa požiadavky, pokiaľ zostávajú pod 80 % limitu. Ak ho prekročia, zachová systémový prompt a odstráni najstaršie správy, kým sa nedostane pod 70 %. Tento rozdiel medzi dvoma prahmi je zámerný: orezanie len na spúšťací prah by spôsobilo, že funkcia bude pri ďalšej správe opäť v červených číslach.

def manage_context(messages: list, max_tokens: int = 100_000) -> list:
    """Udržiavanie správ v rámci limitu tokenov modelu."""
    # Odhad: 1 token ~ 4 znaky vo francúzštine
    total_chars = sum(len(m["content"]) for m in messages)
    estimated_tokens = total_chars // 4

    if estimated_tokens < max_tokens * 0.8:
        return messages  # Všetko sa zmestí

    # Zachovanie systému + prvých a posledných správ
    system = [m for m in messages if m["role"] == "system"]
    history = [m for m in messages if m["role"] != "system"]

    # Odstránenie najstarších správ
    while estimated_tokens > max_tokens * 0.7 and len(history) > 2:
        removed = history.pop(0)
        estimated_tokens -= len(removed["content"]) // 4

    return system + history

Čo si z tohto kurzu odnášaš

Cesta prebehla v štyroch krokoch. Najprv základy: endpoint, roly, základné parametre a štruktúra odpovede. Ďalej streaming s protokolom SSE, jeho implementáciou v Pythone, sekvenciami zastavenia a zabezpečením pomocou safe_prompt a ochranných mechanizmov. Tretiu fázu zaberalo tvorenie promptov – systémové prompty pre produkciu, few-shot, štruktúrovanie pomocou XML a Markdownu, anti-vzory. Pokročilé parametre uzavreli kruh: teplota a Top P v detailoch, penalizácie prítomnosti a frekvencie, N dokončení a tento kontrolný zoznam pre produkciu.

Nižšie uvedená konfigurácia zhrňuje tieto voľby do obhájiteľného východiskového bodu pre prvé nasadenie do produkcie: pevná verzia, strop tokenov prispôsobený použitiu, nízka teplota pre faktickú konzistenciu, top_p nezmenené, keďže sa upravuje teplota, neutrálne penalizácie, ak ich neoprávňuje špecifická potreba, a povolené safe_prompt.

# Typická konfigurácia pre produkčnú aplikáciu
PRODUCTION_CONFIG = {
    "model": "mistral-large-2512",      # Pevná verzia
    "max_tokens": 2000,                  # Prispôsobené použitiu
    "temperature": 0.3,                  # Konzistentné a faktické
    "top_p": 1.0,                        # Nezmenené pri úprave teploty
    "presence_penalty": 0.0,             # Predvolené, ak nie je špecifická potreba
    "frequency_penalty": 0.0,            # Predvolené, ak nie je špecifická potreba
    "safe_prompt": True,                 # Bezpečnosť povolená
}

Ak chceš ísť s API Mistral ďalej, na Corsen Academy ťa čakajú štyri doplnkové kurzy:

  • Embeddings a RAG – Sémantické vyhľadávanie s mistral-embed a vektorovými databázami
  • Function Calling – Prepojenie modelu s tvojimi nástrojmi a externými API
  • Fine-tuning – Prispôsobenie modelu tvojej špecifickej doméne
  • Produkcia a evaluácia – Metriky, automatizované hodnotenia, optimalizácia nákladov

Kľúčové poznatky

  • V produkcii používaj verzované modely, nikdy nie -latest
  • Implementuj opakovanie pokusov + exponenciálne oneskorenie + logovanie hneď pri prvom nasadení
  • Validuj vstupy AJ výstupy každého volania API
  • Sleduj náklady v reálnom čase pomocou sledovača tokenov
  • Spravuj kontextové okno pre dlhé konverzácie
  • Povoľ safe_prompt ako minimálnu bezpečnostnú sieť
  • Pred každým nasadením do produkcie otestuj svoje prompty na hraničných prípadoch

Otestuj si svoje vedomosti

Žiadne tajomstvá v endpointe chat/completions už nemajú byť? Overme si to.

1. Ktoré roly štruktúrujú zoznam správ?

Odpoveď: system (rámec), user (požiadavky), assistant (odpovede modelu) – celá história sa pri každom volaní reštartuje, keďže API je bezstavové.

2. Čo nájdeš v poli usage v odpovedi?

Odpoveď: Tokeny spotrebované na vstupe a výstupe – základ pre fakturáciu a metrika, ktorú treba sledovať pri plánovaní kapacity a nákladov.

3. Ako funguje streaming cez SSE?

Odpoveď: Odpoveď prichádza ako Server-Sent Events, fragment po fragmente: zobrazuješ ich priebežne a spojením získáš finálnu správu.

4. Na čo slúžia sekvencie zastavenia (stop sequences)?

Odpoveď: Na ukončenie generovania hneď, ako sa objaví daný reťazec: kontrola dĺžky, zastavenie na oddeľovači, garantovanie čistých formátov.

5. Teplota, Top P, penalizácie: aké použitie v produkcii?

Odpoveď: Teplota/Top P nastavujú determinizmus podľa úlohy; penalizácie prítomnosti/frekvencie obmedzujú opakovanie – nastavenia, ktoré treba fixovať pre každý prípad použitia a dokumentovať spolu s promptmi.

Roly, využitie, streaming, zastavenia, ladenie: základy platia – vyššie uvedené osvedčené postupy pre produkciu ich uvádzajú do poriadku.