2026.08.15.
AI

Backend prompt hibák kezelése fallback logikával.

Temesvári László

Megbízható prompt kimenetek: amikor az AI nem azt adja, amit vártál

Érzed már te is? Megírsz egy tökéletes promptot, teszteled, működik, aztán élesben valamiért az AI épp olyat válaszol, ami teljesen off. Nem formázott JSON-t ad vissza, hanem szöveget. Vagy épp magyar helyett angolul ír. Vagy egy kicsit kreatívabb módón értelmezi a kérést. Ezek a szituációk mindennaposak a prompt engineering világában, és ha a backend rendszerünk erre nincs felkészítve, könnyen összeomolhat.

A trükk nem abban van, hogy tökéletes promptokat írjunk – bár az is fontos –, hanem hogy a rendszerünk rugalmas legyen és tudjon fallback logikával reagálni, amikor a kimenet nem felel meg az elvárásoknak. Olyan ez, mint egy jó baráti kapcsolat: nem az a fontos, hogy sosem legyen félreértés, hanem hogy legyen tervetek arra, ha mégis az lesz.

Mi is az a fallback logika ebben a kontextusban?

Egyszerűen: egy tervezett B, C, vagy akár D terv arra az esetre, ha az AI válasza nem használható azonnal. Nem csak hibaüzenet kiírásáról van szó, hanem aktív kísérletről a helyzet megoldására. Ez a logika jellemzően a backend rétegben él, ahol kezeljük az AI API hívásokat, és alakítjuk át az eredményt a frontend számára.

Gondolj bele: a frontend (akár jQuery, Bootstrap, vagy React) egy szép, felhasználóbarát űrlapot jelenít meg. A felhasználó megnyomja a „Generálás” gombot. Az adatok eljutnak a PHP backendre, ami meghívja pl. az OpenAI API-t. És itt jön a fallback logika: mi van, ha a válasz nem JSON? Mi van, ha üres? Mi van, ha túl hosszú?

// PHP backend - példa a fallback logika magjára
function getAIPromptResponse($userPrompt, $maxRetries = 2) {
    $retryCount = 0;
    
    while ($retryCount  true, 'data' => $decoded];
            } else {
                // 4. Ha nem JSON, próbáljuk kinyerni a lényeget reguláris kifejezéssel
                $extractedContent = extractContentFromText($rawResponse);
                if ($extractedContent) {
                    // Sikerült menteni a helyzetet
                    return ['success' => true, 'data' => ['content' => $extractedContent], 'note' => 'text_processed'];
                } else {
                    // Ha még ez sem sikerül, új prompttal próbálkozunk
                    $userPrompt = "Kérlek, a következő kérdésre válaszolj egyértelmű, rövid szövegben: " . $userPrompt;
                    $retryCount++;
                }
            }
        } catch (Exception $e) {
            // Logoljuk a hibát
            error_log("AI hívás sikertelen: " . $e->getMessage());
            $retryCount++;
        }
    }
    
    // Ha ideérünk, az összes próbálkozás sikertelen volt
    return [
        'success' => false,
        'data' => ['content' => 'Nem sikerült generálni a választ. Próbáld újra, vagy fogalmazd át a kérdésed.'],
        'error' => 'max_retries_exceeded'
    ];
}

A frontend szerepe: türelmes és tájékoztató interfész

A backend fallback logikája hiába okos, ha a frontend csak a „betöltés…” spinner után egy fehér képernyőt mutat hiba esetén. Itt jön képbe a jQuery, Bootstrap és CSS/SCSS, amikkel rugalmas felhasználói élményt teremthetünk.

// jQuery példa a frontend kérése kezelésére fallback szemlélettel
$('#generateButton').on('click', function() {
    const $button = $(this);
    const $resultDiv = $('#aiResult');
    const originalText = $button.text();
    
    // Állapotváltás: betöltés
    $button.prop('disabled', true).html('<span class="spinner-border spinner-border-sm" role="status"></span> Feldolgozás...');
    $resultDiv.removeClass('alert-danger alert-success').addClass('alert-info').html('Kérés feldolgozása alatt...').show();
    
    $.ajax({
        url: '/backend/ai-handler.php',
        method: 'POST',
        data: { prompt: $('#userPrompt').val() },
        dataType: 'json'
    })
    .done(function(response) {
        if (response.success) {
            // Minden ok, megjelenítjük az eredményt
            $resultDiv.removeClass('alert-info').addClass('alert-success').html(response.data.content);
            
            // Ha volt fallback feldolgozás, jelezzük finoman
            if (response.note === 'text_processed') {
                $resultDiv.append('<small class="d-block mt-2 text-muted"><em>Az AI válaszát speciálisan értelmeztük a megjelenítéshez.</em></small>');
            }
        } else {
            // Backend fallback sem tudott segíteni, felhasználóbarát hiba
            showGracefulError(response.error);
        }
    })
    .fail(function(xhr, status, error) {
        // Hálózati vagy egyéb váratlan hiba
        $resultDiv.removeClass('alert-info').addClass('alert-danger').html(
            'Átmeneti hiba történt. Próbáld meg frissíteni az oldalt, vagy próbáld újra kicsit később.'
        );
    })
    .always(function() {
        // Visszaállítjuk a gombot
        $button.prop('disabled', false).text(originalText);
    });
});

// Egy külön függvény a felhasználóbarát hibakezelésre
function showGracefulError(errorCode) {
    const $resultDiv = $('#aiResult');
    const messages = {
        'max_retries_exceeded': 'Az AI szolgáltatás jelenleg nem elérhető. Kérjük, próbáld újra pár perc múlva.',
        'invalid_format': 'A válasz formátuma nem megfelelő. Próbáld átfogalmazni a kérést.',
        'default': 'Hiba történt a feldolgozás során. Próbáld újra.'
    };
    
    const message = messages[errorCode] || messages['default'];
    $resultDiv.removeClass('alert-info').addClass('alert-danger').html(message);
}

És egy kis SCSS a megfelelő hangulatért:

// Fallback UI állapotok stílusai
#aiResult {
    transition: all 0.3s ease;
    border-left: 4px solid transparent;
    
    &.alert-info {
        border-left-color: $info;
        background-color: lighten($info, 40%);
    }
    
    &.alert-success {
        border-left-color: $success;
        background-color: lighten($success, 50%);
    }
    
    &.alert-danger {
        border-left-color: $danger;
        background-color: lighten($danger, 40%);
        
        // Finom animáció a figyelmeztetéshez
        animation: subtlePulse 2s ease-in-out;
    }
}

@keyframes subtlePulse {
    0%, 100% { opacity: 1; }
    50% { opacity: 0.9; }
}

Gyakori buktatók, amiket érdemes elkerülni

1. Túl korai feladás: Egy sikertelen API hívás után ne adjátok fel azonnal. Egy jól megírt újrapróbálkozási logika (exponential backoff) sok esetet megold. 2. Túl merev elvárások: Ha kizárólag tökéletes JSON-t vártok, kis formai eltérések miatt elvesztek értékes tartalmakat. Legyen rugalmas a parsoló logika. 3. Felhasználó informálásának elmulasztása: Ha a rendszer három próbálkozás után egy egyszerűbb választ ad, jelezzétek ezt a felhasználónak. Az átláthatóság építi a bizalmat. 4. Fallback spirál: Vigyázz, ne ess abba a csapdába, hogy a fallback logika egy végtelen ciklust indít. Mindig legyen maximális próbálkozási korlát és egy tiszta „kiút”. 5. Naplózás hiánya: Minden fallback esetet naplózz! Ezek az adatok aranyat érnek a promptok finomhangolásához és a rendszer javításához.

Összegzés: a rugalmasság mint feature

A megbízható prompt kimenetek kezelése nem arról szól, hogy kiszámíthatatlan AI-t próbálunk meg megbízhatóvá tenni. Hanem arról, hogy elismerjük a valóságot: az AI modellek változóak, a promptok nem mindig egyértelműek, a hálózati körülmények változnak. És ezekre a változásokra tervezünk.

A sikeres megoldás három rétegből áll: 1. Okos backend fallback logika, ami több lépésben próbálja megmenteni a helyzetet. 2. Türelmes és tájékoztató frontend, ami értelmes állapotokat jelenít meg. 3. Folyamatos tanulás: a fallback esetek naplózása és elemzése, amiből fejleszthetjük a promptokat és a rendszert.

Így, amikor legközelebb egy kicsit kreatívabb AI választ kapnál, ne egy hibaüzenet legyen a vége, hanem egy simán továbbgördülő felhasználói élmény. Mert végül is, a technológia lényege az emberek segítése – még akkor is, ha néha egy kis extra logikát igényel a háttérben.

A weboldalon megjelenő szöveges és vizuális tartalmak előállításához mesterséges intelligenciát (AI) használunk.

Kapcsolódó cikkek