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

Ograničenja JSON načina i rukovanje greškama

Lekcija 6 od 12 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Valjano ne znači ispravno
  2. Nema jamstava sheme
  3. Obavezna validacija na strani klijenta
  4. Tri neuspjeha s kojima ćeš se susresti
  5. Ponovni pokušaj s povratnom informacijom
  6. Signal za promjenu pristupa
  7. Ključne točke

Valjano ne znači ispravno

JSON način rada jamči sintaksno valjan JSON, a ne semantički ispravan JSON. Ta razlika može se činiti suptilnom tijekom razvoja, ali postaje kritična u proizvodnji. JSON koji se parsira bez grešaka, ali sadrži neočekivane ključeve, stvara upravo onu vrstu buga koju je teško otkriti danima, jer se nijedna iznimka ne pokreće u trenutku kada se problem zapravo dogodi.

Nema jamstava sheme

Mehanizam ne zna ništa o tvojoj shemi: nikada nije vidio strukturu koju tvoj kod očekuje. Model može izostaviti polje koje ti treba, dodati ono koje nisi tražio, preimenovati ključ – firstName umjesto first_name – ili promijeniti tip vraćanjem "42" kao niza znakova kada si očekivao broj 42. Ništa od toga nije nevaljani JSON.

# Očekuješ ovo:
# {"name": "Alice", "age": 30, "city": "Paris"}

# Ali možeš primiti:
# {"nom": "Alice", "âge": "trente ans", "ville": "Paris", "pays": "France"}

JSON je valjan, ali struktura ne odgovara onome što tvoj kod očekuje. To je temeljna razlika u odnosu na prilagođene strukturirane izlaze.

Obavezna validacija na strani klijenta

Budući da shema nije zajamčena, validacija je tvoja odgovornost. Minimalni obrazac radi tri stvari redom: pokušava parsiranje, provjerava je li korijen objekt (a ne popis ili skalar), zatim provjerava postoje li obavezni ključevi. Svaki neuspjeh podiže ValueError s porukom koju možeš koristiti u svojim zapisnicima.

import json
from typing import Optional

def parse_and_validate(raw_content: str, required_keys: list[str]) -> dict:
    """Parsiraj JSON i provjeri obavezne ključeve."""
    try:
        data = json.loads(raw_content)
    except json.JSONDecodeError as e:
        raise ValueError(f"Nevaljani JSON: {e}")

    if not isinstance(data, dict):
        raise ValueError(f"Očekivan JSON objekt, primljeno {type(data).__name__}")

    missing = [k for k in required_keys if k not in data]
    if missing:
        raise ValueError(f"Nedostaju ključevi: {missing}")

    return data

# Upotreba
try:
    result = parse_and_validate(
        response.choices[0].message.content,
        required_keys=["name", "category", "priority"]
    )
    process_ticket(result)
except ValueError as e:
    log_error(f"Nevaljani izlaz: {e}")
    fallback_processing(raw_content)

TypeScript verzija ide korak dalje provjeravajući, uz prisutnost ključeva, pripada li vraćena kategorija popisu dopuštenih vrijednosti. To je provjera koja najčešće nedostaje, a koja sprječava da tiket klasificiran kao "urgent_billing" tiho prođe kroz tvoje usmjeravanje.

interface TicketClassification {
  category: string;
  priority: string;
  sentiment: string;
  summary: string;
}

function validateTicket(raw: string): TicketClassification {
  const data = JSON.parse(raw);

  const requiredKeys = ["category", "priority", "sentiment", "summary"];
  const missing = requiredKeys.filter((k) => !(k in data));

  if (missing.length > 0) {
    throw new Error(`Nedostaju ključevi: ${missing.join(", ")}`);
  }

  const validCategories = ["billing", "account", "technical", "feature_request", "other"];
  if (!validCategories.includes(data.category)) {
    throw new Error(`Nevaljana kategorija: ${data.category}`);
  }

  return data as TicketClassification;
}

Tri neuspjeha s kojima ćeš se susresti

Prvi je odsječeni JSON. Ako odgovor dosegne ograničenje max_tokens, bit će prekinut usred toka i postati nevaljan – zatvarajuća vitičasta zagrada nikada ne stiže. Simptom možeš uočiti prije samog parsiranja: finish_reason jednak je "length" umjesto "stop".

response = client.chat.complete(
    model="mistral-small-latest",
    messages=messages,
    response_format={"type": "json_object"},
    max_tokens=50  # Premalo za kompletan JSON
)

# response.choices[0].finish_reason bit će "length" umjesto "stop"
if response.choices[0].finish_reason == "length":
    print("Upozorenje: Odsječen odgovor, povećaj max_tokens")

Uvijek provjeri finish_reason: ako je jednak "length", odgovor je nepotpun, bez obzira na to što govori ostatak sadržaja.

Drugi neuspjeh odnosi se na tipove. Dob može stići kao niz znakova, cijena kao cijeli broj kada očekuješ broj s pomičnim zarezom. Umjesto da vjeruješ izlazu, omotaj pristup pomoćnom funkcijom koja pokušava konverziju i vraća zadane vrijednosti ako ne uspije.

def safe_get_int(data: dict, key: str, default: int = 0) -> int:
    """Izdvoji cijeli broj, s konverzijom ako je potrebno."""
    value = data.get(key)
    if value is None:
        return default
    if isinstance(value, int):
        return value
    if isinstance(value, float):
        return int(value)
    if isinstance(value, str):
        try:
            return int(value)
        except ValueError:
            return default
    return default

# Upotreba
age = safe_get_int(data, "age", default=0)

Treći je preimenovanje ključeva. S francuskim upitom, model može lako zamijeniti phone s telephone, ili name s nom. Mapiranje sinonima apsorbira te varijacije bez potrebe da ponavljaš poziv.

def normalize_keys(data: dict, key_mapping: dict) -> dict:
    """Normaliziraj ključeve koristeći mapiranje sinonima."""
    normalized = {}
    for standard_key, aliases in key_mapping.items():
        for alias in aliases:
            if alias in data:
                normalized[standard_key] = data[alias]
                break
    return normalized

# Mapiranje sinonima
mapping = {
    "name": ["name", "nom", "full_name", "fullName"],
    "email": ["email", "mail", "e-mail", "emailAddress"],
    "phone": ["phone", "telephone", "tel", "phoneNumber"],
}

normalized = normalize_keys(raw_data, mapping)

Ponovni pokušaj s povratnom informacijom

Kada validacija ne uspije unatoč tvojim najboljim naporima, najbolji odgovor nije ponoviti točno isti poziv: trebaš reći modelu što je pošlo po zlu. Vraćanjem njegovog vlastitog odgovora natrag u razgovor zajedno s porukom o grešci, daješ mu kontekst potreban za samoispravak, obično već u drugom pokušaju.

import json

def call_with_retry(client, messages, max_retries=3):
    """Poziv s ponovnim pokušajem i povratnom informacijom o grešci."""
    for attempt in range(max_retries):
        response = client.chat.complete(
            model="mistral-large-latest",
            messages=messages,
            response_format={"type": "json_object"},
            temperature=0
        )

        raw = response.choices[0].message.content
        try:
            data = json.loads(raw)
            validate_schema(data)  # Tvoja funkcija za validaciju
            return data
        except (json.JSONDecodeError, ValueError) as e:
            if attempt < max_retries - 1:
                # Dodaj povratnu informaciju o grešci u kontekst
                messages.append({"role": "assistant", "content": raw})
                messages.append({
                    "role": "user",
                    "content": f"Tvoj odgovor je nevaljan: {e}. Ispravi ga i vrati valjani JSON."
                })
            else:
                raise RuntimeError(f"Neuspjeh nakon {max_retries} pokušaja: {e}")

Signal za promjenu pristupa

Ako se uhvatiš kako pišeš opsežan kod za validaciju, to je snažan signal da je vrijeme za prelazak na prilagođene strukturirane izlaze. Tri tipična praga to potvrđuju: kada imaš više od pet polja za validaciju, kontrolna funkcija postaje dulja od samog poziva; čim tipovi postanu složeni s ugniježđenim popisima ili enumeracijama, ručna validacija postaje neodvojiva od bugova koje uvodi; a za bilo koji kritični proizvodni pipeline, delegiranje ograničenja shemi jednostavno je sigurnije nego njihovo ručno rekonstruiranje.

Ključne točke

  • JSON način rada jamči valjani JSON, ne i valjanu shemu
  • Uvijek validiraj izlaz na strani klijenta: provjeri obavezne ključeve, ispravne tipove i vrijednosti unutar granica
  • Provjeri finish_reason kako bi otkrio odsječene odgovore
  • Implementiraj mehanizam ponovnog pokušaja s povratnom informacijom o grešci
  • Ako validacija postane složena, prijeđi na prilagođene strukturirane izlaze