Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Anti-obrasci u API-ju

Lekcija 12 od 16 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Greške koje koštaju novca u produkciji
  2. Tretiranje odsječenog odgovora kao potpunog
  3. Dopuštanje neograničenog rasta povijesti razgovora
  4. Pretpostavljanje da mreža uvijek odgovara
  5. Traženje od modela da učini ono što ne može
  6. Implementacija bez ostavljanja traga
  7. Rutina za otklanjanje grešaka
  8. Ključne točke

Greške koje koštaju novca u produkciji

Nakon što smo pokrili najbolje prakse, vrijeme je da pogledamo drugu stranu medalje. Anti-obrasci u nastavku najčešće su zamke pri korištenju Chat Completions API-ja, a dijele jednu neugodnu osobinu: ne pojavljuju se tijekom razvoja. Od deset testnih zahtjeva sve radi savršeno. Tek u produkciji eksplodiraju, uzrokujući neočekivane troškove, nekoherentne odgovore, visoku latenciju ili, što je još gore, curenje osjetljivih podataka.

Tretiranje odsječenog odgovora kao potpunog

Najčešća greška je ignoriranje finish_reason. Zatražiš ugovor, dobiješ tekst, spremiš ga u bazu: osim što je max_tokens=100 prekinulo generiranje usred klauzule, a nitko to ne primijeti dok klijent ne potpiše. Popravak zahtijeva tri reda koda i trebao bi postati refleks.

# LOŠE — bez provjere
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Draft a complete contract."}],
    max_tokens=100  # Prekratko za ugovor!
)
contract = response.choices[0].message.content  # Potencijalno odsječeno!

# DOBRO — sustavna provjera
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

Dopuštanje neograničenog rasta povijesti razgovora

Druga zamka djeluje polako. Petlja razgovora koja šalje cijelu povijest pri svakom okretu savršeno radi prvih deset razmjena, košta dvostruko više do dvadesetog, a do stotog premašuje prozor konteksta — uz račun koji prati istu krivulju. Rješenje je zadržati sistemski upit (nenegotijabilno) i sačuvati samo posljednjih N poruka.

# LOŠE — povijest raste beskonačno
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 okreta = tisuće tokena!
    )
    reply = response.choices[0].message.content
    conversation.append({"role": "assistant", "content": reply})

# DOBRO — klizni prozor s rezanjem
MAX_MESSAGES = 20

def trim_conversation(messages: list, max_messages: int = MAX_MESSAGES) -> list:
    """Zadržava sistemski upit + posljednjih N poruka."""
    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

Pretpostavljanje da mreža uvijek odgovara

Goli poziv API-ju pretpostavlja da ništa neće poći po zlu: nema isteka vremena, nema 429, nema 500. U produkciji se sva tri događaju, a treće se događa u najgorem mogućem trenutku. Obrati pažnju na razliku u kodu: 429 opravdava eksponencijalno povlačenje, greška poslužitelja zaslužuje sekundu strpljenja, ali greška klijenta poput 400 ili 401 se nikada ne smije ponavljati — tvoj ključ neće postati valjan pri trećem pokušaju; samo ćeš odgoditi dijagnozu.

# LOŠE — bez rukovanja greškama
response = client.chat.complete(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Hello"}]
)
# Ruši se pri isteku vremena, 429, 500...

# DOBRO — ponavljanje s povlačenjem
from mistralai.client.errors import SDKError
import time

def safe_complete(client, messages, max_retries=3, **kwargs):
    """Poziv API-ja s ponavljanjem i eksponencijalnim povlačenjem."""
    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  # Greška klijenta (400, 401) — ne ponavljaj
    raise Exception("Failed after 3 attempts")

Traženje od modela da učini ono što ne može

Ovdje se spajaju tri anti-obrasca. Prvi je subjektivan jezik: „kratak“, „mnogo“, „zanimljiv“ ne odnose se na ništa provjerljivo, pa će model svaki put odlučiti drugačije. Zamijeni svaki pridjev brojem ili opservabilnim kriterijem.

# LOŠE — subjektivno, nemjerljivo
"Write a short summary."           # Kratko = 1 rečenica? 1 odlomak?
"Give many examples."              # Mnogo = 3? 10? 50?
"Answer in an interesting way."    # Zanimljivo po kojim kriterijima?

# DOBRO — objektivni kriteriji
"Write a summary of 50 to 80 words."
"Give exactly 5 examples, one per line."
"Start every response with a relevant statistic."

Drugi je puštanje modelu da broji. LLM-ovi su notorno loši u brojanju riječi, znakova i stavki: traženje „točno 280 znakova“ proizvest će tekst od 240 ili 310. Brojanje pripada tvojoj aplikaciji, a ne modelu.

# LOŠE — model ne može precizno brojati
"Write exactly 280 characters for a tweet."

# DOBRO — brojanje na strani aplikacije
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}")

Treći spada u istu obitelj: numeričke ljestvice. „Ocijeni od 1 do 5“ pretpostavlja da model ima stabilnu reprezentaciju razmaka između 3 i 4, što nema. Verbalna ljestvica gdje je svaki korak definiran kriterijem daje mnogo reproducibilnije ocjene.

# LOŠE — modeli loše tumače numeričke ljestvice
"Rate the quality of this text from 1 to 5."

# DOBRO — verbalna ljestvica s definicijama
"""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."""

Implementacija bez ostavljanja traga

Posljednji anti-obrazac je najdiskretniji: pozivanje API-ja, vraćanje sadržaja i čuvanje ničega. Dan kada korisnik prijavi aberantni odgovor, nemaš ni ID zahtjeva, ni stvarni model koji je poslužio, ni potrošnju tokena. Strukturirano bilježenje po pozivu košta nekoliko milisekundi i omogućuje istragu.

# LOŠE — bez traga
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages
)
return response.choices[0].message.content

# DOBRO — strukturirano bilježenje
import logging
import json

logger = logging.getLogger("mistral_api")

def logged_complete(client, messages, **kwargs):
    """Poziv API-ja sa strukturiranim bilježenjem."""
    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

Rutina za otklanjanje grešaka

Kada odgovor ne ispuni tvoja očekivanja, napast je prepisati upit. Umjesto toga, započni s pet mehaničkih provjera, redom: Je li odgovor potpun? Je li odgovorio ispravan model? Koliko je tokena potrošeno? Je li odgovor prazan? Je li omjer izlaza i ulaza vjerodostojan? Omjer ispod 1% na velikom upitu gotovo uvijek signalizira da je model odbio obraditi zahtjev, a ne da ga je loše obradio.

def debug_response(response):
    """Kontrolni popis za otklanjanje grešaka kod neočekivanih odgovora."""
    choice = response.choices[0]

    # 1. Je li odgovor potpun?
    if choice.finish_reason == "length":
        print("ISSUE: Response truncated — increase max_tokens")

    # 2. Je li korišten ispravan model?
    print(f"Model: {response.model}")

    # 3. Koliko je tokena potrošeno?
    print(f"Input tokens: {response.usage.prompt_tokens}")
    print(f"Output tokens: {response.usage.completion_tokens}")

    # 4. Je li odgovor prazan?
    if not choice.message.content or not choice.message.content.strip():
        print("ISSUE: Empty response")

    # 5. Sumnjiv omjer ulaza/izlaza?
    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})")

Ključne točke

  • Uvijek provjeri finish_reason kako bi otkrio/la odsijecanje
  • Ograniči povijest razgovora kliznim prozorom
  • Implementiraj ponavljanje s eksponencijalnim povlačenjem za mrežne greške
  • Koristi objektivne, mjerljive kriterije u svojim upitima
  • Nikada ne puštaj modelu da broji — validiraj na strani aplikacije
  • Bilježi svaki poziv API-ja u produkciji radi otklanjanja grešaka i praćenja troškova