FLUX.2 Klein Eğitimi: Gradio ile Üret ve Düzenle Görsel Uygulaması Oluşturma

Adım 1: Ortam kurulumu

Görsel üretim ve düzenleme uygulamamızı oluşturmadan önce, en güncel Diffusers kütüphanesiyle temiz bir ortam kurmamız gerekiyor. Bu eğitim için, daha hızlı görsel üretimi adına A100 GPU’lu bir Google Colab oturumunda her şeyi çalıştıracağız. Bununla birlikte, aynı kurulum, biraz daha yavaş performansla T4 gibi daha mütevazı GPU’larda da çalışır.

Sürümler arası çakışmalardan kaçınmak için önce yüklü herhangi bir Diffusers sürümünü kaldırıp, ardından en son geliştirme sürümünü doğrudan GitHub’dan kuruyoruz. Ayrıca model yükleme, kontrol noktası yönetimi ve hızlandırma için gereken destekleyici kütüphaneleri de yüklüyoruz.

!pip -q uninstall -y diffusers
!pip -q install -U git+https://github.com/huggingface/diffusers.git
!pip -q install -U accelerate safetensors transformers huggingface_hubAltyapı:

Kurulum tamamlandığında, yüklü Diffusers sürümünü kontrol ediyor ve ardından Flux2KleinPipeline sınıfının başarıyla içe aktarılabildiğini doğruluyoruz.

import diffusers
print("diffusers:", diffusers.__version__)
from diffusers import Flux2KleinPipeline
print("Flux2KleinPipeline import OK")Altyapı:

Bu, ortamımızın doğru şekilde yapılandırıldığını teyit eder. Bir sonraki adımda, FLUX.2 Klein modelini GPU’ya yükleyip hem yerel görsel üretim hem de API tabanlı düzenleme iş akışları için hazırlayacağız.

Adım 2: FLUX.2 Klein 4B’yi yükleyin 

Modeli yüklemeden önce, Black Forest Labs’ten bir API anahtarına ihtiyacınız var. Başlamak için Black Forest Labs hesabınıza giriş yapın ve Credits sekmesi altında kredi ekleyin. Minimum yükleme yaklaşık on dolardır ve yaklaşık bin kredi sağlar. Krediler eklendikten sonra Create Key’e tıklayın, açıklayıcı bir ad verin ve güvenli bir yerde saklayın.

API anahtarınız hazır olduğunda, bir sonraki adım FLUX.2 Klein 4B modelini yüklemek ve onu iki farklı kullanım modu için hazırlamaktır: yerel görsel üretimi ve API tabanlı görsel düzenleme. 

import os, time, base64, io, requests
import gradio as gr
import torch
import nest_asyncio
from PIL import Image
from diffusers import Flux2KleinPipeline
from google.colab import userdata
nest_asyncio.apply()
# =============================
# LOAD via API
# =============================
MODEL_ID = "black-forest-labs/FLUX.2-klein-4B"
BFL_API_KEY = userdata.get("BFL_API_KEY")
BFL_CREATE_URL = "https://api.bfl.ai/v1/flux-2-klein-4b"
print(f"Loading model to GPU: {torch.cuda.get_device_name(0)}")
# =============================
# LOAD via LOCAL HF PIPELINE
# =============================
dtype = torch.float16 
pipe = Flux2KleinPipeline.from_pretrained(MODEL_ID, torch_dtype=dtype).to("cuda")Altyapı:

Önce API anahtarını bir Colab sırrı olarak ayarlıyor, böylece not defteri kodunda asla görünmüyor. Ayrıca model kimliğini ve daha sonra çağıracağımız Klein düzenleme uç noktasını tanımlıyoruz. 

Daha sonra, olay döngüsü çakışmalarını tetiklememek için Gradio arayüzünü başlatmadan önce nest_asyncio uygularız.

Son olarak, temel görsel üretimi için yerel FLUX.2 Klein hattını yükleyin. Geniş GPU uyumluluğu (A100 ve T4 iyi çalışır) için float16 ile Flux2KleinPipeline kullanıyor, ardından hızlı kestirim için hattı CUDA’ya taşıyoruz. Bu yerel hat yalnızca ilk görseli üretmek için kullanılır; düzenlemeler API üzerinden gerçekleştirilir.

Not: Bu noktada, neden modeli yerelde yükleyip aynı zamanda API erişimi yapılandırdığımızı merak edebilirsiniz. Nedeni, yetenek ayrımıdır:

• Yerel Hugging Face hattı, yinelemeli metinden görsele üretim ve kestirim ayarları üzerinde tam kontrol için idealdir.
• Black Forest Labs API’si, şu anda açık ağırlıklı uygulamada bulunmayan, birden fazla referans görselle istem tabanlı görsel düzenleme gibi FLUX.2 Klein için gelişmiş görsel düzenleme özelliklerini sunar.

Her iki yaklaşımı birleştirerek, her iki dünyanın en iyisini elde ederiz: yerel üretim hızı ve düzenleme desteği.

Adım 3: Yardımcı fonksiyonlar

Her şeyi Gradio arayüzüne bağlamadan önce, küçük bir yardımcı fonksiyon setine ihtiyacımız var. Uygulamamız görselleri yerelde üretip düzenlemeleri API üzerinden yaptığı için, API istekleri için görselleri base64’e kodlamanın bir yoluna, URL olarak dönen düzenlenmiş görselleri indirmenin bir yoluna ve ilk temel görseli üreten yerel bir üretim fonksiyonuna ihtiyacımız var.

def pil_to_b64_png(img: Image.Image) -> str:
    buf = io.BytesIO()
    img.convert("RGB").save(buf, format="PNG")
    return base64.b64encode(buf.getvalue()).decode()
def url_to_pil(url: str) -> Image.Image:
    r = requests.get(url, timeout=60)
    r.raise_for_status()
    return Image.open(io.BytesIO(r.content)).convert("RGB")
def local_generate(prompt: str):
    if not prompt.strip():
        raise gr.Error("Prompt is empty.")
    out = pipe(
        prompt=prompt.strip(),
        width=1024,
        height=1024,
        num_inference_steps=4,
        guidance_scale=1.0,
        output_type="pil",
    )
    return out.images[0].convert("RGB")Altyapı:

Yukarıdaki kod üç temel yardımcı fonksiyonu tanımlar:

• pil_to_b64_png() fonksiyonu, bir PIL görselini base64 ile kodlanmış PNG dizesine dönüştürür. Bu gereklidir; çünkü FLUX.2 düzenleme API’si temel görseli ve referans görselleri URL veya base64 dizesi olarak kabul eder. 
• url_to_pil() fonksiyonu ters yönü ele alır. Düzenleme API’si oluşturulan çıktı için imzalı bir URL döndürür; bu nedenle bu URL’yi requests ile alır, yanıtı doğrular ve indirilen baytları tekrar bir PIL görseline dönüştürürüz. Bu, düzenlenmiş sonucun Gradio arayüzümüzde doğrudan gösterilmesini ve geçmişe kaydedilmesini sağlar.
• Son olarak, local_generate() fonksiyonu yerel metinden görsele giriş noktamızdır. İstemin boş olmadığını doğrular, ardından çözünürlük, adım sayısı ve yönlendirme ölçeği gibi sabit ayarlarla yerel Flux2KleinPipeline’ı çağırır. Çıktı, sonraki düzenlemeler için temel görsel haline gelecek temiz bir RGB PIL görseli olarak döndürülür.

FLUX hattı ayarlarıyla, örneğin görsel çözünürlüğü, difüzyon adımları ve yönlendirme ölçeğiyle oynayarak farklı kalite-hız ödünleşimlerini keşfedebilir ve her parametrenin nihai görseli nasıl etkilediğini daha iyi anlayabilirsiniz. 

Flux 2 görsel düzenleme dokümantasyonu bu ayarlar hakkında daha fazla bilgi edinmek için iyi bir başlangıçtır.

Bir sonraki adımda, FLUX.2 Klein ile API tabanlı görsel düzenlemeyi uygulamak için bu yardımcıları kullanacağız.

Adım 4: BFL API üzerinden düzenleme

Bu adım, yalnızca Hugging Face iş akışı ile bu eğitimde kullanılan hibrit yaklaşım arasındaki temel farktır. Görsel düzenlemeyi yerelde çalıştırmaya çalışmak yerine, düzenlemeleri API’ye devrediyoruz; bu da istem tabanlı düzenlemeleri ve isteğe bağlı çoklu referans koşullandırmayı güvenilir şekilde ele alır.

Üst düzeyde, FLUX.2 Klein düzenleme API’si düzenlemeyi tanımlayan bir metin istemi, değiştirilecek bir temel görsel ve ek girdiler olarak sağlanan isteğe bağlı referans görseller bekler. API eşzamansız çalışır; yani bir istek gönderir ve düzenlenen görsel hazır olana kadar dönen bir URL’yi yoklarız.

POLL_INTERVAL_S = 1.0
POLL_TIMEOUT_S = 120
def bfl_edit(edit_prompt, base_img, ref_imgs=None):
    if not BFL_API_KEY:
        raise gr.Error("Missing BFL_API_KEY in Colab Secrets.") 
    payload = {
        "prompt": edit_prompt.strip(),
        "input_image": pil_to_b64_png(base_img),
        "output_format": "png",
    }
    if ref_imgs:
        for i, ref in enumerate(ref_imgs[:3], start=2):
            payload[f"input_image_{i}"] = pil_to_b64_png(ref)
    create = requests.post(
        BFL_CREATE_URL,
        headers={"x-key": BFL_API_KEY, "accept": "application/json"},
        json=payload,
        timeout=60,
    )
    create.raise_for_status()
    job = create.json()
    polling_url = job.get("polling_url")
    if not polling_url:
        raise gr.Error(f"API Error: {job}")
    t0 = time.time()
    while True:
        if time.time() - t0 > POLL_TIMEOUT_S:
            raise gr.Error("BFL API polling timed out.")  
        time.sleep(POLL_INTERVAL_S)
        res = requests.get(polling_url, headers={"x-key": BFL_API_KEY})
        res.raise_for_status()
        j = res.json()
        if j["status"] == "Ready":
            return url_to_pil(j["result"]["sample"])
        if j["status"] in ("Error", "Failed"):
            raise gr.Error(f"Generation Failed: {j}")Altyapı:

bfl_edit() fonksiyonu üç önemli şey yapar:

• Düzenleme istemi, değiştirmek istediğimiz temel görsel ve isteğe bağlı bir referans görsel listesi olmak üzere üç girdi alır. 
• Düzenleme istemi ve temel görseli base64 PNG olarak kodlayıp bir JSON yükü oluştururuz. Referans görseller sağlanırsa, bunları API’nin indeksli formatını kullanarak ekleriz. Bu, temel görselle birlikte üç referans görsele kadar sağlamamıza olanak tanır; renk paleti aktarımı, stil sabitleme veya nesne temellendirme gibi birçok pratik iş akışı için yeterlidir.
• Ardından isteği uç noktaya gönderip yanıtı ayrıştırırız. API, işi bitene kadar tekrar tekrar sorgulamamız gereken bir polling_url döndürür. Bunu, aşırı isteği önleyen bir yoklama aralığı ve not defterinin süresiz beklemesini önleyen bir zaman aşımı olmak üzere iki emniyetli unsurla basit bir yoklama döngüsüyle uygularız.

Durum Ready olduğunda, API yanıtı çıktı görseline ait imzalı bir URL içerir. Bu görseli önceki url_to_pil() yardımcı fonksiyonumuzla indirip bir PIL görseli olarak döndürürüz.

Bir sonraki adımda, kullanıcıların üretilen veya düzenlenen çıktılardan herhangi birine geri dönebilmeleri için oturum geçmişini uygulayacağız.

Adım 5: Geçmiş ekleme 

Bu noktada, arayüzü oluşturmadan önce ihtiyaç duyduğumuz son parça, kullanıcıların önceki çıktılara geri dönebilmesi için hafif bir oturum belleği katmanıdır. Geçmişi iki Gradio durum (state) nesnesi kullanarak uygularız:

• base_img_state, üzerinde çalışılan mevcut görseli (gelecekteki düzenlemelerin uygulanacağı görseli) saklar.
• history_state, her üretilen veya düzenlenen sürümü, her biri bir görsel ve kısa bir etiket içeren sözlük listesi olarak saklar.

def update_history(history):
    choices = [f"{i}: {h['label']}" for i, h in enumerate(history or [])]
    return gr.update(choices=choices, value=choices[-1] if choices else None)
def on_generate(prompt, history):
    img = local_generate(prompt)
    new_history = list(history or [])
    new_history.append({"img": img, "label": "Generated Base"})
    return img, img, new_history, update_history(new_history), "Base image generated."
def on_edit(edit_prompt, ref2, ref3, ref4, base_img, history):
    if base_img is None:
        raise gr.Error("Please generate a base image first.")
    refs = [r.convert("RGB") for r in (ref2, ref3, ref4) if r is not None]
    out = bfl_edit(edit_prompt, base_img, refs)
    new_history = list(history or [])
    new_history.append({"img": out, "label": f"Edit: {edit_prompt[:20]}..."})
    return out, out, new_history, update_history(new_history), "Edit successful."
def on_load(choice, history):
    if not history or not choice:
        return None, None, "No history to load."
    idx = int(choice.split(":")[0])
    img = history[idx]["img"]
    return img, img, f"Loaded entry #{idx}."
def on_clear():
    return None, None, [], gr.update(choices=[], value=None), "Cleared everything."Altyapı:

Yukarıdaki fonksiyonlar, demomuzda görsel geçmişini korumanın çekirdek mantığını oluşturur:

• update_history() fonksiyonu, oturum geçmişini bir açılır menüye biçimlendirir. Her giriş, indeks ve kısa bir açıklama ile etiketlenir; açılır menü varsayılan olarak en yeni öğeyi otomatik seçer. Bu, manuel yenileme mantığı gerektirmeden arayüzü senkron tutar.
• on_generate() geri çağrısı, ilk temel görseli oluşturmak için local_generate()’i çalıştırır. Sonucu {"img": img, "label": "Generated Base"} olarak geçmişe ekler. Fonksiyon hem görseli hem güncellenen geçmiş durumunu hem de yeni girdinin hemen görünür olmasını sağlayan açılır menü güncellemesini döndürür.
• on_edit() geri çağrısı benzer şekilde çalışır; ancak bunun yerine bfl_edit()’i çağırır. Mevcut çalışma görselini temel görsel olarak alır, bazı isteğe bağlı referans görsellerle API üzerinden düzenlemeyi uygular ve çıktıyı geçmişe ekler. Ayrıca düzenlenmiş çıktıyı yeni base_img_state olarak döndürür; yani kullanıcı açıkça daha eski bir sürümü yüklemediği sürece sonraki düzenlemeler en güncel görsele uygulanır.
• on_load() geri çağrısı, seçilen açılır menü girdisini ayrıştırır, karşılık gelen görseli history_state’ten alır ve bu görseli yeniden etkin çalışma görseli yapar. Bu, kullanıcıların düzenlemelerini önceki herhangi bir kontrol noktasından dallandırabilmesini sağlar.
• Son olarak, on_clear() fonksiyonu her şeyi sıfırlar. Çıktıyı temizler, temel görsel durumunu sıfırlar, geçmiş listesini temizler ve açılır menü seçeneklerini boşaltır.

Şimdi bu fonksiyonları iki metin kutusu, isteğe bağlı referans yüklemeleri ve bir geçmiş iş akışıyla bir Gradio arayüzüne bağlayalım.

Adım 6: Gradio arayüzü

Bu adım, üretim, düzenleme ve geçmiş mantığımızı basit bir Gradio arayüzüne bağlar. Arayüz, yerleşim üzerinde ince ayar kontrolü sağlayan gr.Blocks ile oluşturulmuştur. 

with gr.Blocks() as demo:
    gr.Markdown("## FLUX.2 Klein: Generate & Edit Images")
    with gr.Row():
        with gr.Column(scale=1):
            gen_prompt = gr.Textbox(label="1. Generate Base Image", placeholder="A young boy riding a scooter...")
            gen_btn = gr.Button("Generate Base Image", variant="primary")
            edit_prompt = gr.Textbox(label="2. Describe Edits", placeholder="Add the red hat and yellow glasses from the references...")
            with gr.Accordion("Reference Images (Optional)", open=False):
                r2 = gr.Image(label="Ref 1", type="pil")
                r3 = gr.Image(label="Ref 2", type="pil")
                r4 = gr.Image(label="Ref 3", type="pil")
            edit_btn = gr.Button("Apply Edit", variant="secondary") 
            history_dd = gr.Dropdown(label="Session History", choices=[])
            with gr.Row():
                load_btn = gr.Button("Load Selected")
                clear_btn = gr.Button("Clear All")
            status = gr.Textbox(label="Status", interactive=False)
        with gr.Column(scale=1):
            output_view = gr.Image(label="Current Image", type="pil")
    base_img_state = gr.State(None)
    history_state = gr.State([])
    gen_btn.click(
        on_generate, 
        [gen_prompt, history_state], 
        [output_view, base_img_state, history_state, history_dd, status]
    ) 
    edit_btn.click(
        on_edit, 
        [edit_prompt, r2, r3, r4, base_img_state, history_state], 
        [output_view, base_img_state, history_state, history_dd, status]
    ) 
    load_btn.click(
        on_load, 
        [history_dd, history_state], 
        [output_view, base_img_state, status]
    )
    clear_btn.click(
        on_clear, 
        None, 
        [output_view, base_img_state, history_state, history_dd, status]
    )
demo.launch(share=True, inline=True, debug = True)Altyapı:

Arayüzü iki sütuna ayırıyoruz: sol sütunda girdiler ve işlemler, sağ sütunda ise mevcut görsel yer alır. Gradio uygulamasını şu şekilde oluşturuyoruz:

• İlk metin kutusu üretim istemini toplar ve Generate Base Image düğmesi on_generate() fonksiyonunu tetikler. Bu geri çağrı, yerel üretimi çalıştırır, çıktıyı geçmişe kaydeder ve hem gösterilen görseli hem de base_img_state içinde saklanan mevcut çalışma görselini günceller.
• İkinci metin kutusu, bir düzenleme talimatı istemi toplar. Kullanıcı Apply Edit düğmesine tıkladığında, mevcut çalışma görselini temel görsel olarak kullanan ve düzenlenmiş çıktıyı döndüren on_edit() fonksiyonunu çağırırız. Düzenlenmiş çıktı ayrıca geçmişe eklenir ve sonraki düzenlemeler için yeni çalışma görseli olur.
• İş akışını oturum farkında yapmak için bir Session History açılır menüsü de ekliyoruz; her giriş, görselin kaydedilmiş bir sürümüne karşılık gelir. Load Selected düğmesi, seçilen geçmiş görselini geri yükleyip onu yeniden mevcut çalışma görseli yapan on_load()’u tetikler. 
• Son olarak, Clear All düğmesi, on_clear() fonksiyonu aracılığıyla çıktıyı, temel görsel durumunu ve kaydedilen geçmişi de içerecek şekilde her şeyi sıfırlar.

Aşağıdaki iki Gradio State nesnesi her şeyi tutarlı kılar:

• base_img_state, her düzenlemenin doğru görsele uygulanmasını sağlar.
• history_state, yeniden oynatma ve dallanma için çıktıların tam zaman çizelgesini saklar.

Son olarak, demo.launch() uygulamayı Colab’de başlatır, paylaşılabilir bir bağlantı sağlar, sayfa içinde görüntüler ve geliştirme sırasında sorunları teşhis etmeye yardımcı olmak için hata ayıklama günlüklerini etkinleştirir.

FLUX.2 Klein Örnekleri ve Gözlemler

FLUX.2 Klein’in pratikte nasıl davrandığını anlamak için, nihai Üret ve Düzenle uygulamasını kullanarak küçük bir dizi deney yaptım. Üç ana etkileşim desenini test ettim: temel görsel üretimi, yalnızca istemle düzenleme ve bir veya daha fazla görsel kullanarak referans güdümlü düzenleme. Ayrıca, önceki herhangi bir çıktıyı geri yükleyip o noktadan düzenlemeye devam edebildiğimi doğrulamak için oturum geçmişi iş akışını da doğruladım.

Görsel üretimi

Temiz bir temel görsel oluşturmak için basit bir üretim istemiyle başladım. Model, tutarlı aydınlatma, keskin yüz detayları ve dengeli bir sahne yerleşimiyle uyumlu bir özne üretti. Çıktı olarak alınan temel görsel, yeniden üretim yapmak yerine sonraki düzenlemeler için güçlü ve kullanışlı görünüyordu.

Tek referans görselle görsel düzenleme

Sonra, bir rengi kaynak almak için tek bir referans görsel test ettim ve “Elbisenin rengini referans görseldeki renge değiştir.” gibi bir düzenleme talimatı kullandım. Düzenleme, niyet edilen rengi başarıyla aktardı ve orijinal sahne yapısının çoğunu korudu.

Gözlemime göre, tek referanslı düzenlemeler, istem dar ve sınırlı olduğunda en iyi sonucu veriyor. Renk aktarımı ve gardırop yeniden renklendirme, büyük geometrik değişiklikler gerektirmediği için özellikle güvenilirdir. Düzenleme talimatı tek bir özelliğe odaklandığında, özne kimliği ve arka plan detayları stabil kalır.

Tek bir istemle görsel düzenleme

Ardından, “Arka planı bir plajla değiştir.” gibi semantik bir değişiklikle yalnızca isteme dayalı düzenlemeyi denedim. Model, özneyi kabaca tutarlı tutarken arka plan ikamesini temiz bir şekilde ele aldı. 

Arka plan değiştiğinde, model genellikle sonucu fotogerçekçi tutmak için renk sıcaklığını ve gölge yoğunluğunu ayarlar. Bu genellikle bir artıdır; ancak düzenlenen görselin basit bir kes-yapıştırdan ziyade farklı bir fotoğraf çekimi gibi görünmesine yol açabilir.

Poz yönlendirme

Vücut konumlandırmasını ima eden bir referans görsel kullanarak ve “Referans görseldeki pozu eşle.” gibi bir istemle poz tabanlı bir düzenleme test ettim. Ortaya çıkan görsel, benzer bir kimlik ve stilizasyonu korurken öznenin pozunu değiştirdi.

Poz yönlendirmesi için kullandığım referans görsel şuydu:

Poz düzenlemeleri yapılabilir; ancak renk düzenlemelerine göre daha hassastır. Herhangi bir poz değişikliği, kumaşın düşüşü, uzuv konumları ve kamera kadrajı gibi ikincil değişiklikleri tetikleyebilir. Bu pozu doğru almak için birkaç deneme yapmam gerekti ve bacak konumuyla hâlâ zorlanıyordu.

Birden fazla referans görselle görsel düzenleme

Son olarak, bir renk paleti referansı ve “Yalnızca arka plan renklerini referans görsellerdeki paletten kullanarak değiştir. Arka planı referans görsellerle değiştirme.” şeklinde açıkça belirten bir düzenleme istemi gibi birkaç girdi kullanarak çoklu referans düzenlemelerini test ettim. 

Şaşırtıcı biçimde, çoklu referans düzenleme

, her referans görselin net bir rolü olduğunda en etkilidir. 

Palet referansları, istem yalnızca palet vurgusunu açıkça belirttiğinde ve modelin referans içeriğini ikame olarak kullanmasını istemekten kaçındığında iyi çalışır. 

Referanslar muğlak olduğunda, model yalnızca renkten ziyade doku veya yerleşim ipuçlarını ödünç alabilir.  Benim çalıştırmamda, referans görsellere benzeyen öğelerin sahneye hafifçe sızdığı birkaç küçük yapaylık fark ettim; ancak genel sonuç yine de güçlü ve görsel olarak tutarlı görünüyordu.

Bu demonun pratik bir faydası, üretilen ve düzenlenen her görselin oturum geçmişine kaydedilmesidir. Önceki herhangi bir girdiyi yükleyip tam o kontrol noktasından düzenlemeye devam edebilirsiniz. Bu, denemeyi çok daha hızlı hale getirir. Daha önceki bir sürümden düzenlemeleri dallandırabilir, birden çok düzenleme yönünü karşılaştırabilir ve iyi bir ara sonucu kaybetmekten kaçınabilirsiniz. 

Sonuç

Bu eğitimde, FLUX.2 Klein 4B kullanarak eksiksiz bir üretim ve görsel düzenleme iş akışı oluşturduk. Diffusers üzerinden yerel metinden görsele üretimi, Black Forest Labs’in barındırılan düzenleme API’siyle birleştirerek etkileşimli bir görsel düzenleyici oluşturabildik.

FLUX.2 Klein’in düşük gecikmesi, birleşik üretim ve düzenleme yetenekleri ile çoklu referans desteği, onu bu tür etkileşimli iş akışları için özellikle uygun kılar. Buradan, uygulamayı toplu düzenleme, parametre kontrolleri, oturumlar arası kalıcılık veya düzenlemeleri otomatik olarak öneren LLM destekli bir ajanla genişletebilirsiniz.