Yapay Zeka Yanıtlarını Önbelleğe Almak: Masaüstü Uygulamalarda Maliyetten Nasıl Tasarruf Edersiniz?

Yapay zeka destekli masaüstü uygulamaları geliştirirken karşılaşılan en büyük sorunlardan biri, kullanıcılar aynı sorguyu tekrar sorduğunda gereksiz API istekleriyle karşılaşmaktır. Google’ın Gemini modeli gibi hizmetler, her çağrıda ücretlendirildiğinden, aynı girdiye tekrar yanıt üretilmesi hem maliyetli hem de gereksizdir.

Peki, kullanıcılar hata teşhis penceresini kapatıp tekrar açtığında ne yapılmalı? Cevap basit: Yanıtı önbelleğe almak.

Aynı Girdi, Aynı Yanıt: Önbelleğin Temel Mantığı

Yapay zeka tabanlı bir teşhis aracı düşünün. Kullanıcı, hata satırındaki bir sorunu çözmek için "Bu hatanın nedenini analiz et" butonuna tıklıyor. Sistem, ilgili log içeriğini Google’ın Gemini API’sine gönderiyor ve yanıtı aldıktan sonra ekrana yansıtıyor.

Ancak kullanıcı pencereyi kapatıp tekrar açtığında, aynı log içeriği için tekrar API çağrısı yapılmamalı. Çünkü:

• Aynı girdi → Aynı çıktı prensibiyle çalışan yapay zeka modellerinde, aynı sorgunun tekrar gönderilmesi gereksizdir.
• API kota sınırlarını korumak için, her gereksiz çağrı hem maliyet hem de gecikme anlamına gelir.
• Kullanıcı deneyimini hızlandırmak adına, önbelleğe alınmış yanıtlar anında sunulabilir.

Bu yaklaşım, HiyokoLogcat adlı masaüstü uygulamasının geliştiricisi tarafından benimsenen bir yöntemdir. Uygulama, kullanıcıların aynı hatayı tekrar sorgulaması durumunda, yanıtı önbellekten çekerek hem hız hem de maliyet avantajı sağlıyor.

Önbellek Anahtarı: Girdiyi Hash’leyerek Eşsiz Bir Tanımlayıcı Oluşturma

Önbelleğin etkili çalışabilmesi için, girdinin benzersiz bir şekilde temsil edilmesi gerekiyor. Bunun için SHA-256 hash algoritması kullanılıyor. Bu sayede:

• Aynı log içeriği için her zaman aynı hash değeri üretilir.
• Farklı içerikler için farklı hash değerleri oluşur.
• Önbellek, gereksiz yere büyümez ve gereksiz verilerle doldurulmaz.

Aşağıdaki Rust kod parçası, önbellek yapısını ve hashleme işlemini nasıl uyguladığını gösteriyor:

use std::collections::HashMap;
use sha2::{Sha256, Digest};

pub struct DiagnosisCache {
    entries: HashMap<String, CacheEntry>,
    max_size: usize,
}

#[derive(Clone)]
pub struct CacheEntry {
    pub result: String,
    pub created_at: std::time::Instant,
}

impl DiagnosisCache {
    pub fn new(max_size: usize) -> Self {
        Self {
            entries: HashMap::new(),
            max_size,
        }
    }

    pub fn key(context: &str) -> String {
        let mut hasher = Sha256::new();
        hasher.update(context.as_bytes());
        format!("{:x}", hasher.finalize())
    }

    pub fn get(&self, key: &str) -> Option<&CacheEntry> {
        self.entries.get(key)
    }

    pub fn insert(&mut self, key: String, result: String) {
        // Önbellek kapasitesi dolduysa en eski girişi sil
        if self.entries.len() >= self.max_size {
            if let Some(oldest_key) = self.entries
                .iter()
                .min_by_key(|(_, v)| v.created_at)
                .map(|(k, _)| k.clone())
            {
                self.entries.remove(&oldest_key);
            }
        }

        self.entries.insert(
            key,
            CacheEntry {
                result,
                created_at: std::time::Instant::now(),
            },
        );
    }
}

Uygulama İçinde Kullanım: Önbellek Kontrolü ve API Çağrısı

Önbelleğin uygulama içinde nasıl kullanıldığına dair bir başka Rust örneği aşağıda yer alıyor. Bu kod parçası, diagnose adlı bir fonksiyonu gösteriyor:

#[tauri::command]
pub async fn diagnose(
    context: String,
    api_key: String,
    cache: tauri::State<'_, Mutex<DiagnosisCache>>,
) -> Result<String, String> {
    let key = DiagnosisCache::key(&context);

    // Önce önbelleği kontrol et
    {
        let cache = cache.lock().unwrap();
        if let Some(entry) = cache.get(&key) {
            return Ok(entry.result.clone()); // Anında yanıt
        }
    }

    // Önbellek bulunamadıysa, Gemini API’sini çağır
    let result = call_gemini(&context, &api_key).await?;

    // Yanıtı önbelleğe kaydet
    {
        let mut cache = cache.lock().unwrap();
        cache.insert(key, result.clone());
    }

    Ok(result)
}

Bu yapı, önce önbelleği kontrol eder, eğer ilgili yanıt varsa anında döner. Eğer yoksa, Gemini API’sini çağırır, yanıtı alır ve önbelleğe kaydeder.

Önbellek Boyutu ve Süresi: Ne Kadar Saklamalı?

Önbellek boyutunun ne kadar olması gerektiği önemli bir detaydır. HiyokoLogcat’ta 50 girişlik bir önbellek yeterli görülüyor, çünkü:

• Log satırları sürekli değişir. İki saat önceki bir log içeriği, genellikle tekrar sorgulanmaz.
• Uygulama yeniden başlatıldığında önbellek temizlenebilir. Alternatif olarak, TTL (Time-To-Live) mekanizması eklenerek önbellek girişleri belirli bir süre sonra otomatik olarak silinebilir.

Önbelleğin uygulama başında nasıl kaydedildiğine dair basit bir örnek:

// main.rs içinde kaydetme
.manage(Mutex::new(DiagnosisCache::new(50)))

Sonuç: Hız ve Maliyet Avantajı

Uygulamaya önbellek katmanı eklendikten sonra yapılan testlerde, ilk teşhis yanıtı 3 saniye sürerken, sonraki aynı sorgular anında yanıt verdiği gözlemlendi. Bu sayede:

• API çağrı sayısı önemli ölçüde azaldı.
• Kullanıcı deneyimi hızlandı.
• API maliyetleri düştü.

Bu basit ama etkili yöntem, yapay zeka destekli masaüstü uygulamalarının performansını ve maliyet etkinliğini artırmak için güçlü bir araç sunuyor. Özellikle sık kullanılan sorguların tekrarlandığı senaryolarda, önbellekleme stratejileri hem geliştiricilere hem de kullanıcılara büyük fayda sağlıyor.

Uygulamanızda API çağrı maliyetlerini azaltmak ve yanıt sürelerini kısaltmak istiyorsanız, yapay zeka yanıtlarını önbelleğe almayı unutmayın.