Anti-patterny API
Na této stránce
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ů