Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Anti-patterny API

Lekce 12 z 16 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Chyby, které v produkci stojí peníze
  2. Pokládání useknuté odpovědi za úplnou
  3. Nechání historie konverzace růst bez omezení
  4. Předpoklad, že síť vždy odpoví
  5. Požadování toho, co model neumí
  6. Nasazení bez zanechání stopy
  7. Postup ladění
  8. Klíčové poznatky

Chyby, které v produkci stojí peníze

Poté, co jsme probrali osvědčené postupy, je čas podívat se na druhou stranu mince. Níže uvedené anti-patterny jsou nejčastějšími pastmi při používání API Chat Completions a mají jednu nepříjemnou vlastnost: během vývoje se neprojeví. Z deseti testovacích požadavků vše funguje perfektně. Až v produkci to exploduje, což způsobí neočekávané náklady, nesourodé odpovědi, vysokou latenci nebo, což je horší, únik citlivých dat.

Pokládání useknuté odpovědi za úplnou

Nejčastější chybou je ignorování finish_reason. Požádáš o smlouvu, dostaneš zpět nějaký text, uložíš ho do databáze: jenže max_tokens=100 přerušilo generování uprostřed klauzule a nikdo si toho nevšimne, dokud ji klient nepodepíše. Oprava zabere tři řádky kódu a měla by se stát reflexem.

# ŠPATNĚ — žádná kontrola
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Draft a complete contract."}],
    max_tokens=100  # Příliš krátké na smlouvu!
)
contract = response.choices[0].message.content  # Potenciálně useknuté!

# DOBŘE — 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("WARNING: Response truncated, increase max_tokens")
else:
    contract = response.choices[0].message.content

Nechání historie konverzace růst bez omezení

Druhá past spouští pomalu. Smyčka chatu, která při každém kroku odesílá celou historii konverzace, funguje perfektně prvních deset výměn, do dvacáté stojí dvojnásobek a do stého překročí kontextové okno – přičemž faktura sleduje stejnou křivku. Řešením je ponechat systémový prompt (není o čem diskutovat) a udržovat pouze posledních N zpráv.

# ŠPATNĚ — historie roste donekonečna
conversation = []
while True:
    user_input = input("You: ")
    conversation.append({"role": "user", "content": user_input})
    response = client.chat.complete(
        model="mistral-large-latest",
        messages=conversation  # 100 kol = tisíce tokenů!
    )
    reply = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": reply})

# DOBŘE — posuvné okno s ořezáváním
MAX_MESSAGES = 20

def trim_conversation(messages: list, max_messages: int = MAX_MESSAGES) -> list:
    """Udrží systémový prompt + posledních N zprá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

Předpoklad, že síť vždy odpoví

Holé volání API předpokládá, že se nic nepokazí: žádné časové limity, žádné chyby 429, žádné 500. V produkci se dějí všechny tři a ta třetí nastane v tu nejhorší možnou chvíli. Všimni si rozdílu v kódu: u chyby 429 je na místě exponenciální backoff, u chyby serveru stačí sekunda trpělivosti, ale chyba klienta jako 400 nebo 401 se nikdy nesmí opakovat – tvůj klíč se při třetím pokusu nestane platným; pouze oddálíš diagnostiku.

# ŠPATNĚ — žádná obsluha chyb
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Hello"}]
)
# Zhroucení při timeoutu, 429, 500...

# DOBŘE — opakování s backoffem
from mistralai.client.errors import SDKError
import time

def safe_complete(client, messages, max_retries=3, **kwargs):
    """Volání API s opakováním a exponenciálním backoffem."""
    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"Rate limit hit, waiting {wait}s...")
                time.sleep(wait)
            elif e.status_code >= 500:
                time.sleep(1)
            else:
                raise  # Chyba klienta (400, 401) — neopakovat
    raise Exception("Failed after 3 attempts")

Požadování toho, co model neumí

Zde se sbíhají tři anti-patterny. Prvním je subjektivní jazyk: „krátký“, „mnoho“, „zajímavý“ se nevztahují k ničemu ověřitelnému a model se bude při každém volání rozhodovat jinak. Nahraď každé přídavné jméno číslem nebo pozorovatelným kritériem.

# ŠPATNĚ — subjektivní, neměřitelné
"Write a short summary."           # Krátký = 1 věta? 1 odstavec?
"Give many examples."              # Mnoho = 3? 10? 50?
"Answer in an interesting way."    # Zajímavý podle jakých kritérií?

# DOBŘE — objektivní kritéria
"Write a summary of 50 to 80 words."
"Give exactly 5 examples, one per line."
"Start every response with a relevant statistic."

Druhým je nechání počítání na modelu. LLM jsou notoricky špatné v počítání slov, znaků a položek: požadavek na „přesně 280 znaků“ vyprodukuje text o 240 nebo 310 znacích. Počítání patří do tvé aplikace, ne do modelu.

# ŠPATNĚ — model neumí počítat přesně
"Write exactly 280 characters for a tweet."

# DOBŘE — počítej na straně aplikace
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Write a tweet about AI in France."}],
    max_tokens=100
)

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

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

Třetí spadá do stejné rodiny: numerické škály. „Ohodnoť od 1 do 5“ předpokládá, že model má stabilní reprezentaci rozdílu mezi 3 a 4, což nemá. Verbální škála, kde je každý krok definován kritériem, poskytuje mnohem reprodukovatelnější hodnocení.

# ŠPATNĚ — modely špatně interpretují numerické škály
"Rate the quality of this text from 1 to 5."

# DOBŘE — verbální škála s definicemi
"""Rate the quality of this text according to the following scale:
- EXCELLENT: Clear, well-structured, no errors
- GOOD: Generally correct, minor improvements possible
- AVERAGE: Understandable but lacks structure or contains errors
- POOR: Difficult to understand, significant errors
- VERY POOR: Incomprehensible or off-topic

Respond only with the label in uppercase."""

Nasazení bez zanechání stopy

Poslední anti-pattern je nejnepatrnější: zavolat API, vrátit obsah a nic neuchovat. V den, kdy uživatel nahlásí absurdní odpověď, nemáš ani ID požadavku, ani skutečný obsloužený model, ani spotřebu tokenů. Strukturované logování pro každé volání stojí pár milisekund a umožňuje vyšetřování.

# ŠPATNĚ — žádná stopa
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)
return response.choices[0].message.content

# DOBŘE — strukturované logování
import logging
import json

logger = logging.getLogger("mistral_api")

def logged_complete(client, messages, **kwargs):
    """Volání API se strukturovaným logování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 ladění

Když odpověď nesplňuje tvá očekávání, pokušení přepsat prompt je velké. Místo toho začni pěti mechanickými kontrolami v pořadí: Je odpověď úplná? Odpověděl správný model? Kolik tokenů bylo spotřebováno? Je odpověď prázdná? Je poměr výstup/vstup věrohodný? Poměr pod 1 % u velkého promptu téměř vždy signalizuje, že model odmítl požadavek zpracovat, spíše než že by ho špatně zpracoval.

def debug_response(response):
    """Kontrolní seznam ladění pro neočekávané odpovědi."""
    choice = response.choices[0]

    # 1. Je odpověď úplná?
    if choice.finish_reason == "length":
        print("ISSUE: Response truncated — increase max_tokens")

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

    # 3. Kolik tokenů bylo spotřebováno?
    print(f"Input tokens: {response.usage.prompt_tokens}")
    print(f"Output tokens: {response.usage.completion_tokens}")

    # 4. Je odpověď prázdná?
    if not choice.message.content or not choice.message.content.strip():
        print("ISSUE: Empty response")

    # 5. Podezřelý poměr vstup/výstup?
    ratio = response.usage.completion_tokens / max(response.usage.prompt_tokens, 1)
    if ratio < 0.01:
        print(f"WARNING: Very low output/input ratio ({ratio:.4f})")

Klíčové poznatky

  • Vždy kontroluj finish_reason, abys odhalil useknutí
  • Omez historii konverzace pomocí posuvného okna
  • Implementuj opakování s exponenciálním backoffem pro chyby sítě
  • Používej v promptech objektivní, měřitelná kritéria
  • Nikdy nenechávej počítat model – validuj na straně aplikace
  • V produkci loguj každé volání API kvůli ladění a sledování nákladů