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

Anti-vzorce pri práci s API

Lekcia 12 z 16 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Chyby, ktoré ťa v produkcii budú stáť peniaze
  2. Pokladanie orezanej odpovede za úplnú
  3. Neobmedzený rast histórie konverzácie
  4. Predpoklad, že sieť vždy odpovie
  5. Požadovanie nemožného od modelu
  6. Nasadenie bez zanechania stopy
  7. Postup ladenia
  8. Kľúčové poznatky

Chyby, ktoré ťa v produkcii budú stáť peniaze

Po prebratí osvedčených postupov je čas pozrieť sa na druhú stranu mince. Nižšie uvedené anti-vzorce predstavujú najčastejšie pasce pri používaní API Chat Completions a spája ich jedna nepríjemná vlastnosť: počas vývoja sa neprejavia. Z desiatich testovacích požiadaviek všetko funguje ako hodinky. Problémy nastanú až v produkcii, kde spôsobujú neočakávané náklady, nekonzistentné odpovede, vysokú latenciu alebo, čo je horšie, únik citlivých údajov.

Pokladanie orezanej odpovede za úplnú

Najčastejšou chybou je ignorovanie poľa finish_reason. Požiadaš o zmluvu, dostaneš späť nejaký text, uložíš ho do databázy – až na to, že max_tokens=100 prerušilo generovanie uprostred vety a nikto si to nevšimne, kým klient zmluvu nepodpíše. Oprava zaberie tri riadky kódu a mala by sa stať tvojím reflexom.

# ZLE — žiadna kontrola
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Draft a complete contract."}],
    max_tokens=100  # Príliš krátke na zmluvu!
)
contract = response.choices[0].message.content  # Potenciálne orezané!

# DOBRE — systematická kontrola
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Draft a complete contract."}],
    max_tokens=4000
)

if response.choices[0].finish_reason == "length":
    print("UPOZORNENIE: Odpoveď bola orezaná, zvýš max_tokens")
else:
    contract = response.choices[0].message.content

Neobmedzený rast histórie konverzácie

Druhá pasca sa prejavuje pomaly. Chatovacia slučka, ktorá pri každom kroku odosiela celú históriu konverzácie, perfektne funguje prvých desať výmen, do dvadsiateho zdvojnásobí náklady a pri stotej výmene prekročí kontextové okno – pričom faktúra rastie rovnakým tempom. Riešením je ponechať systémový prompt (nenegotiovateľné) a uchovávať iba posledných N správ.

# ZLE — história rastie donekonečna
conversation = []
while True:
    user_input = input("Ty: ")
    conversation.append({"role": "user", "content": user_input})
    response = client.chat.complete(
        model="mistral-large-latest",
        messages=conversation  # 100 kôl = tisíce tokenov!
    )
    reply = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": reply})

# DOBRE – posuvné okno s orezávaním
MAX_MESSAGES = 20

def trim_conversation(messages: list, max_messages: int = MAX_MESSAGES) -> list:
    """Ponechá systémový prompt a posledných N správ."""
    system = [m for m in messages if m["role"] == "system"]
    history = [m for m in messages if m["role"] != "system"]

    if len(history) > max_messages:
        history = history[-max_messages:]

    return system + history

Predpoklad, že sieť vždy odpovie

Holé volanie API predpokladá, že sa nič nepokazí: žiadne časové limity, žiadne chyby 429, žiadne chyby 500. V produkcii sa však vyskytnú všetky tri a tá tretia príde v tú najnevhodnejšiu chvíľu. Všimni si rozdiel v kóde: pri chybe 429 je na mieste exponenciálne oneskorenie (backoff), pri chybe servera stačí sekunda trpezlivosti, ale chyby klienta ako 400 alebo 401 sa nikdy nesmú opakovať – tvoj kľúč sa nestane platným až pri treťom pokuse; len oddiališ diagnostiku problému.

# ZLE — žiadne ošetrenie chýb
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Hello"}]
)
# Spadne pri časovom limite, 429, 500...

# DOBRE — opakovanie s exponenciálnym oneskorením
from mistralai.client.errors import SDKError
import time

def safe_complete(client, messages, max_retries=3, **kwargs):
    """Volanie API s opakovaním a exponenciálnym oneskorením."""
    for attempt in range(max_retries):
        try:
            return client.chat.complete(messages=messages, **kwargs)
        except SDKError as e:
            if e.status_code == 429:
                wait = 2 ** attempt
                print(f"Dosiahnutý limit rýchlosti, čakám {wait}s...")
                time.sleep(wait)
            elif e.status_code >= 500:
                time.sleep(1)
            else:
                raise  # Chyba klienta (400, 401) — neopakovať
    raise Exception("Zlyhanie po 3 pokusoch")

Požadovanie nemožného od modelu

Tu sa stretávajú tri anti-vzorce. Prvým je subjektívny jazyk: výrazy ako „krátky“, „mnoho“, „zaujímavý“ sa nevzťahujú na nič overiteľné a model sa bude pri každom volaní rozhodovať inak. Každé prídavné meno nahraď číslom alebo pozorovateľným kritériom.

# ZLE — subjektívne, nemerateľné
"Napíš krátke zhrnutie."           # Krátke = 1 veta? 1 odsek?
"Uveď mnoho príkladov."            # Mnoho = 3? 10? 50?
"Odpovedz zaujímavým spôsobom."    # Zaujímavý podľa akých kritérií?

# DOBRE — objektívne kritériá
"Napíš zhrnutie v rozsahu 50 až 80 slov."
"Uveď presne 5 príkladov, každý na novom riadku."
"Každú odpoveď začni relevantnou štatistikou."

Druhým problémom je nechávať model počítať. LLM sú notoricky zlé v počítaní slov, znakov a položiek: požiadavka na „presne 280 znakov“ vyprodukuje text s dĺžkou 240 alebo 310 znakov. Počítanie patrí do tvojej aplikácie, nie do modelu.

# ZLE — model nedokáže presne počítať
"Napíš presne 280 znakov pre tweet."

# DOBRE — počítaj na strane aplikácie
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Napíš tweet o AI vo Francúzsku."}],
    max_tokens=100
)

tweet = response.choices[0].message.content
if len(tweet) > 280:
    tweet = tweet[:277] + "..."

print(f"Tweet ({len(tweet)} znakov): {tweet}")

Tretí problém patrí do tej istej rodiny: numerické škály. „Ohodnoť od 1 do 5“ predpokladá, že model má stabilné vnímanie rozdielu medzi 3 a 4, čo nemá. Verbálna škála, kde je každý stupeň definovaný konkrétnym kritériom, prináša oveľa reprodukovateľnejšie hodnotenia.

# ZLE — modely zle interpretujú numerické škály
"Ohodnoť kvalitu tohto textu od 1 do 5."

# DOBRE — verbálna škála s definíciami
"""Ohodnoť kvalitu tohto textu podľa nasledujúcej škály:
- VÝBORNÁ: Jasná, dobre štruktúrovaná, bez chýb
- DOBRÁ: Všeobecne správna, možné drobné vylepšenia
- PRIEMERNÁ: Zrozumiteľná, ale chýba jej štruktúra alebo obsahuje chyby
- SLABÁ: Ťažko zrozumiteľná, významné chyby
- VEĽMI SLABÁ: Nezrozumiteľná alebo mimo témy

Odpovedz iba označením veľkými písmenami."""

Nasadenie bez zanechania stopy

Posledný anti-vzorec je najnenápadnejší: zavoláš API, vrátiš obsah a nič neuložíš. V deň, keď používateľ nahlási absurdnú odpoveď, nemáš ani ID požiadavky, ani názov skutočne použitého modelu, ani spotrebu tokenov. Štruktúrované logovanie každého volania stojí pár milisekúnd a umožní ti následnú investigáciu.

# ZLE — žiadna stopa
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)
return response.choices[0].message.content

# DOBRE — štruktúrované logovanie
import logging
import json

logger = logging.getLogger("mistral_api")

def logged_complete(client, messages, **kwargs):
    """Volanie API so štruktúrovaným logovaním."""
    response = client.chat.complete(messages=messages, **kwargs)

    logger.info(json.dumps({
        "request_id": response.id,
        "model": response.model,
        "prompt_tokens": response.usage.prompt_tokens,
        "completion_tokens": response.usage.completion_tokens,
        "finish_reason": response.choices[0].finish_reason
    }))

    return response

Postup ladenia

Keď odpoveď nezodpovedá tvojim očakávaniam, pokušením je prepísať prompt. Namiesto toho začni piatimi mechanickými kontrolami v poradí: Je odpoveď úplná? Odpovedal správny model? Koľko tokenov sa spotrebovalo? Je odpoveď prázdna? Je pomer výstup/vstup vierohodný? Pomer pod 1 % pri veľkom prompte takmer vždy signalizuje, že model odmietol spracovať požiadavku, namiesto toho, aby ju zle vybavil.

def debug_response(response):
    """Kontrolný zoznam ladenia pre neočakávané odpovede."""
    choice = response.choices[0]

    # 1. Je odpoveď úplná?
    if choice.finish_reason == "length":
        print("PROBLÉM: Odpoveď orezaná – zvýš max_tokens")

    # 2. Bol použitý správny model?
    print(f"Model: {response.model}")

    # 3. Koľko tokenov sa spotrebovalo?
    print(f"Vstupné tokeny: {response.usage.prompt_tokens}")
    print(f"Výstupné tokeny: {response.usage.completion_tokens}")

    # 4. Je odpoveď prázdna?
    if not choice.message.content or not choice.message.content.strip():
        print("PROBLÉM: Prázdna odpoveď")

    # 5. Podozrivý pomer vstup/výstup?
    ratio = response.usage.completion_tokens / max(response.usage.prompt_tokens, 1)
    if ratio < 0.01:
        print(f"UPOZORNENIE: Veľmi nízky pomer výstup/vstup ({ratio:.4f})")

Kľúčové poznatky

  • Vždy kontroluj finish_reason, aby si odhalil orezanie odpovede
  • Obmedz históriu konverzácie pomocou posuvného okna
  • Implementuj opakovanie s exponenciálnym oneskorením pre chyby siete
  • Používaj v promptoch objektívne a merateľné kritériá
  • Nikdy nenechávaj model počítať – validuj to na strane aplikácie
  • Loguj každé volanie API v produkcii kvôli ladeniu a sledovaniu nákladov