2026.07.16.
AI

AI API költségek csökkentése tokenméréssel.

Temesvári László

Az AI API költségcsökkentés titkai: cache és okos tokenmérés

Ha már dolgoztál AI API-kkal (legyen az OpenAI, Anthropic vagy bármely más szolgáltató), biztos ismerős a hónap végén érkező számla kis meglepetése. A token alapú díjszabás gyorsan összeadódik, főleg ha felhasználóink szeretik használni az alkalmazásodat. De ne aggódj, vannak trükkök, amikkel jelentősen lefaraghatsz a költségekről anélkül, hogy a felhasználói élmény rovására menne.

Miért számítanak a tokenek?

Először is, tisztázzuk az alapokat. Amikor AI API-hoz kommunikálsz, minden kérésed tokenekben mérődik. Egy token nagyjából 3/4 szó, de a pontos konverzió függ a nyelvtől. Az API díjszabása általában ezer tokenre vonatkozik, és külön díjazzák a bemeneti (prompt) és kimeneti (completion) tokeneket.

A probléma ott kezdődik, hogy ismétlődő kérdésekre is mindig új tokeneket fizetsz, holott a válasz gyakran ugyanaz lenne. Itt jön be a cache, a fejlesztők régi jó barátja.

A cache mágiája AI kontextusban

Képzeld el ezt a forgatókönyvet: van egy gyakran ismétlődő kérdésed, például „Mik azok a tervezési minták?” vagy „Hogyan kell egy REST API-t dokumentálni?”. Ha minden alkalommal, amikor egy felhasználó ezt kérdezi, új API hívást indítasz, feleslegesen költesz tokenekre.

PHP-ban egy egyszerű cache megoldás lehet így:

<?php
class AICacheManager {
    private $cacheDuration = 3600; // 1 óra
    
    public function getCachedResponse($prompt, $apiFunction) {
        $cacheKey = md5($prompt . $apiFunction);
        
        // Egyszerű fájl alapú cache (élesben Redis vagy Memcached jobb lenne)
        $cacheFile = __DIR__ . '/cache/' . $cacheKey . '.json';
        
        if (file_exists($cacheFile) && 
            (time() - filemtime($cacheFile)) < $this->cacheDuration) {
            return json_decode(file_get_contents($cacheFile), true);
        }
        
        return null;
    }
    
    public function saveResponse($prompt, $apiFunction, $response) {
        $cacheKey = md5($prompt . $apiFunction);
        $cacheFile = __DIR__ . '/cache/' . $cacheKey . '.json';
        
        if (!is_dir(__DIR__ . '/cache')) {
            mkdir(__DIR__ . '/cache', 0755, true);
        }
        
        file_put_contents($cacheFile, json_encode($response));
    }
}

// Használat
$cacheManager = new AICacheManager();
$prompt = "Magyarázd el a singleton tervezési mintát";
$cached = $cacheManager->getCachedResponse($prompt, 'gpt-4');

if ($cached) {
    $response = $cached;
} else {
    // API hívás
    $response = $openAI->complete($prompt);
    $cacheManager->saveResponse($prompt, 'gpt-4', $response);
}
?>

Okos tokenmérés a frontenden

A cache segít az ismétlődő kérdéseknél, de mi van azzal, amikor a felhasználók túl hosszú promptokat írnak? Itt jön a tokenmérés a frontend oldalon. Egy egyszerű JavaScript megoldás figyelmeztetheti a felhasználót, ha a kérdése túl hosszú (és túl költséges) lesz.

// Egyszerűsített token számító jQuery-val
$(document).ready(function() {
    $('#prompt-input').on('input', function() {
        const text = $(this).val();
        const estimatedTokens = estimateTokens(text);
        
        $('#token-counter').text('Becsült tokenek: ' + estimatedTokens);
        
        // Figyelmeztetés, ha túl sok a token
        if (estimatedTokens > 2000) {
            $('#token-warning')
                .removeClass('d-none')
                .html('<i class="bi bi-exclamation-triangle"></i> Túl hosszú prompt! A költség jelentősen növekedhet.');
        } else {
            $('#token-warning').addClass('d-none');
        }
    });
    
    function estimateTokens(text) {
        // Egyszerűsített becslés: szavak száma * 0.75
        const wordCount = text.trim().split(/\s+/).length;
        return Math.ceil(wordCount * 0.75);
    }
});

És egy kis SCSS a megjelenítéshez:

.token-counter {
    font-size: 0.875rem;
    color: $gray-600;
    margin-top: 0.25rem;
    
    &.warning {
        color: $orange;
        font-weight: 500;
    }
    
    &.critical {
        color: $red;
        font-weight: 600;
    }
}

#token-warning {
    @extend .alert;
    @extend .alert-warning;
    margin-top: 1rem;
    animation: fadeIn 0.3s ease-in;
    
    i {
        margin-right: 0.5rem;
    }
}

Gyakori buktatók, amiket kerülj

1. Túl hosszú cache élettartam: AI válaszok is elavulhatnak, főleg ha időérzékeny információkról van szó. Állíts be különböző cache időket a prompt típusától függően.

2. Kontextus figyelmen kívül hagyása: Ha a beszélgetés kontextusához kapcsolódó promptod van, ne cacheljed agresszívan. A „folytasd ahol abbahagytuk” típusú kéréseknél a cache ártalmas lehet.

3. Token becslés pontatlansága: A fenti JavaScript példa egy egyszerűsített becslés. Pontosabb eredményhez fontolóra vehetsz egy kis PHP backend számítást vagy speciális tokenizáló könyvtárat.

4. User-specific adatok cache-elése: Soha ne cachelj személyes vagy felhasználói adatokat AI válaszokban anélkül, hogy megfelelően anonimizálnád őket.

Mikor ne használj cache-t?

– Dinamikus, valós idejű információkhoz (pl. „mi a jelenlegi BTC árfolyam?”) – Erősen személyre szabott válaszoknál – Amikor a kontextus kritikus (többszörös üzenetváltás) – Tesztelési vagy fejlesztési környezetben

Röviden összefoglalva

Az AI API költségek optimalizálása nem csak a számla csökkentéséről szól, hanem hatékonyabb alkalmazás készítéséről is. A cache segít kiküszöbölni a felesleges ismétlődéseket, míg a tokenmérés felület segít a felhasználóknak tudatosabbnak lenni arról, mit kérdeznek.

A legjobb stratégia általában a kettő kombinációja: cache-elj mindent, ami ismétlődő és nem időérzékeny, és adj visszajelzést a felhasználóknak a promptjaik „költségéről”. Így nem csak a pénztárcád, de a felhasználói élmény is javulni fog – hiszen senki sem szeret várakozni feleslegesen API válaszokra, amik már el lettek készítve korábban.

*Egy fejlesztői suttogás: a legjobb cache az, amit a felhasználó észre sem vesz, de a számlán igen.*

Kapcsolódó cikkek