Ajan mantığına giriş

# Bir "ajan" (agent), model çıktısının bir kısmını "araç çağrısı" (tool call) olarak
# yorumlayıp gerçek bir fonksiyon çalıştıran, sonucu tekrar bağlama ekleyen bir sistemdir.
# İlk araç: güvenli bir hesap makinesi. Neden ham eval() kullanmıyoruz?
OPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
       ast.Div: operator.truediv, ast.Pow: operator.pow, ast.USub: operator.neg}

def guvenli_hesapla(ifade):
    def degerlendir(dugum):
        if isinstance(dugum, ast.Constant):
            return dugum.value
        if isinstance(dugum, ast.BinOp):
            return OPS[type(dugum.op)](degerlendir(dugum.left), degerlendir(dugum.right))
        if isinstance(dugum, ast.UnaryOp):
            return OPS[type(dugum.op)](degerlendir(dugum.operand))
        raise ValueError(f"Desteklenmeyen ifade: {ast.dump(dugum)}")
    agac = ast.parse(ifade, mode="eval")
    return degerlendir(agac.body)

print(f"guvenli_hesapla('30 * 2') = {guvenli_hesapla('30 * 2')}")

# Ham eval() kullansaydık ne olurdu? Model çıktısı (ya da kötü niyetli bir kullanıcı)
# Zararlı bir "ifade" göndererek keyfi kod çalıştırabilirdi:
ZARARLI_GIRDI = '__import__("os").system("echo bu calismamali")'
try:
    guvenli_hesapla(ZARARLI_GIRDI)
    print("Güvenlik açığı: zararlı kod çalıştı!")
except (ValueError, KeyError, SyntaxError) as e:
    print(f"\nZararlı girdi ('{ZARARLI_GIRDI}') güvenli biçimde reddedildi: {type(e).__name__}")
print("Sadece sayı ve aritmetik işlem düğümlerine (BinOp) izin veren bir ayrıştırıcı (AST),")
print("ham eval()'ın açtığı keyfi kod çalıştırma riskini tamamen kapatıyor.")

# İkinci araç: 11. dersteki aynı TF-IDF getirme motoru.
BELGELER = [
    "Academyou AI, yapay zeka eğitimi sunan bir platformdur.",
    "Academyou AI ücretsiz derslerini 2026 yılında yayınlamaya başladı.",
    "Academyou AI platformunda Türkçe dilinde 150'den fazla ders bulunur.",
    "İade politikamıza göre, satın alınan ürünler 30 gün içinde iade edilebilir.",
    "Müşteri destek ekibimize hafta içi 09.00-18.00 arasında ulaşabilirsiniz.",
    "Şirketimiz 2023 yılında İstanbul'da kuruldu.",
]

def tokenize(s):
    return s.lower().replace(".", "").replace(",", "").replace("'", "").split()

def tf(belge):
    kelimeler = tokenize(belge)
    return {k: v / len(kelimeler) for k, v in Counter(kelimeler).items()}

def idf(belgeler):
    N = len(belgeler)
    sayim = Counter()
    for b in belgeler:
        for k in set(tokenize(b)):
            sayim[k] += 1
    return {k: math.log(N / v) for k, v in sayim.items()}

idf_degerleri = idf(BELGELER)
tum_kelimeler = sorted(set(k for b in BELGELER for k in tokenize(b)))

def tfidf_vektor(belge):
    tf_d = tf(belge)
    return [tf_d.get(k, 0) * idf_degerleri.get(k, 0) for k in tum_kelimeler]

def kosinus(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    na, nb = math.sqrt(sum(x*x for x in a)), math.sqrt(sum(x*x for x in b))
    return dot / (na * nb + 1e-10)

def belge_ara(sorgu):
    sv = tfidf_vektor(sorgu)
    benzerlikler = [(i, kosinus(sv, tfidf_vektor(b))) for i, b in enumerate(BELGELER)]
    en_iyi = max(benzerlikler, key=lambda x: x[1])
    return BELGELER[en_iyi[0]], en_iyi[1]

sonuc, skor = belge_ara("iade süresi")
print(f"\nbelge_ara('iade süresi') = (\"{sonuc}\", {skor:.3f})")

# Bir ajan döngüsü (ReAct tarzı): düşün -> Araç seç -> Çalıştır -> Gözlemle -> Tekrarla
# -> Son cevap. Model bu ortamda gerçek bir LLM olmadığı için, "Düşünce" adımları
# öğretici amaçlı elle senaryolandırıldı -- ama araç çağrılarının sonuçları gerçektir.
SORU = "İade süresi kaç gün, ve bu sürenin 2 katı kaç gün eder?"
print(f"\nSoru: \"{SORU}\"\n")

print("Adım 1 -- düşünce: Önce iade süresini bulmam lazım.")
print("Adım 1 -- araç çağrısı: belge_ara(\"iade süresi\")")
belge, skor = belge_ara("iade süresi")
print(f"Adım 1 -- gözlem: \"{belge}\" (benzerlik: {skor:.3f})")

print("\nAdım 2 -- düşünce: Belgede '30 gün' yazıyor. Şimdi 30'un 2 katını hesaplamalıyım.")
print("Adım 2 -- araç çağrısı: guvenli_hesapla(\"30 * 2\")")
iki_kati = guvenli_hesapla("30 * 2")
print(f"Adım 2 -- gözlem: {iki_kati}")

print(f"\nSon cevap: İade süresi 30 gün; bunun 2 katı {iki_kati} gün eder.")
print("\nBu döngüde iki araç (getirme + hesaplama) sırayla çağrıldı -- her aracın sonucu,")
print("bir sonraki adımın bağlamının parçası oldu (17. dersteki otoregresif üretimle aynı ilke,")
print("şimdi araç sonuçlarıyla genişletilmiş bir bağlamda).")

# 2. dersteki uyarıyı hatırla: her ajan adımı, bağlama yeni token'lar ekler -- uzun bir
# ajan döngüsü, aynı karesel maliyet büyümesi riskini taşır.
adim_token_maliyetleri = [15, 22, 18, 25]  # Öğretici amaçlı örnek (her adımın yaklaşık token maliyeti)
kumulatif = 0
print(f"\n{'Adım':<8} {'Bu adımın maliyeti':<20} {'Kümülatif bağlam'}")
for i, m in enumerate(adim_token_maliyetleri, 1):
    kumulatif += m
    print(f"{i:<8} {m:<20} {kumulatif}")
print(f"\n4 adımlık bir ajan döngüsü, bağlamı {adim_token_maliyetleri[0]}'ten {kumulatif}'e büyüttü --")
print("2. dersteki aynı 'her tur tüm geçmişi taşır' riski, ajan döngülerinde de geçerlidir,")
print("hatta araç sonuçları (belge parçaları, API yanıtları) genelde metinden daha uzundur.")