Gemini 3 API Eğitimi: Gemini 3 Pro ve LangGraph ile Veri Analizini Otomatikleştirme

Gemini 3 Pro, tek bir geçişte veri kümelerini, belgeleri, videoları ve kod tabanlarını zahmetsizce işleyen, bir milyon belirteçlik devasa bağlam penceresine sahip, hepimizin beklediği son teknoloji yapay zeka modelidir. Metin, görsel, ses ve videonun çok modlu işlenmesinde mükemmeldir ve yaratıcı iş akışlarında kesintisiz deneyim sunarken doktora seviyesinde akıl yürütme sağlar.

Bu proje tabanlı eğitimde, kullanıcı tarafından sağlanan bir CSV veri kümesini kullanan ve derin veri analitiği gerçekleştiren çoklu ajan uygulamaları oluşturmak için Gemini 3 API’yi nasıl kullanacağınızı göstereceğim. 

Kısacası, çoklu ajan uygulaması şunları yapacak:

• Basit analizler: Veri kümesinin yapısını ve temel unsurlarını hızla keşfeder.
• Kod üretimi: Görselleştirmelerle birlikte ileri düzey analiz kodunu Gemini 3 Pro ile oluşturur.
• Güvenli çalıştırma: Kodu izole bir ortamda çalıştırır ve sonuçları kaydeder.
• Akıllı akıl yürütme: Temel içgörüler için bulguları analiz eder ve yorumlar.
• PDF rapor derleme: Görseller ve net açıklamalarla, saniyeler içinde kavranabilecek içgörüler içeren, özenli bir PDF üretir.

Ajanik yapay zeka iş akışları hakkında daha fazla bilgi edinmek istiyorsanız, Google Antigravity rehberimizi, Gemini 3 Flash eğitimini ve AI Agent Fundamentals beceri yolunu incelemenizi öneririm.

1. Gemini 3 API Ortamını Kurma

1. Çoklu ajan uygulamamız için gerekli tüm paketleri yüklemek üzere bu komutu çalıştırın:

!pip install -q google-genai langgraph langsmith grandalf pydantic pandas matplotlib markdown2 weasyprint markdown-it-py mdit-py-plugins

Paket Özeti:

• google-generativeai: Resmi API üzerinden Gemini 3 Pro’ya erişin.
• langgraph: Çoklu ajanlı yapay zeka iş akışlarını kolayca düzenleyin.
• langsmith: Çalıştırmaları takip edin, performansı izleyin ve etkileşimli panolarla hata ayıklayın.
• grandalf: Ajan grafiklerini temiz ASCII diyagramları olarak görselleştirin.
• pydantic: Paylaşılan grafik durumlarını sağlam veri doğrulamayla yönetin.
• pandas: Hızlı veri kümesi keşfi ve analizi yapın.
• matplotlib: Etkileyici veri görselleştirmeleri üretin.
• markdown2: Zengin rapor biçimlendirmesi için Markdown’ı HTML’e dönüştürün.
• weasyprint: HTML/CSS’i profesyonel PDF raporlara dönüştürün.
• markdown-it-py: Karmaşık biçimlendirme için gelişmiş bir Markdown ayrıştırıcısı.
• mdit-py-plugins: Tablolar, dipnotlar ve daha fazlası için markdown-it-py’ı eklentilerle genişletin.

Not: Bu projeyi oluşturmak için Jupyter Notebook kullanıyoruz.

2. Google AI Studio’ya gidin ve API anahtarınızı oluşturun. Gemini 3 Pro modelinin ücretsiz katmanda bulunmadığını unutmayın; hesabınızda faturalandırmanın ayarlı olduğundan emin olun. 

3. Ardından, ücretsiz bir LangSmith hesabı oluşturun ve API anahtarını üretin. 

4. Her iki API anahtarını da yerel sisteminizde ortam değişkeni olarak kaydedin. LANGSMITH_API_KEY ve GEMINI_API_KEY değişkenlerini ayarlayın.

5. Defterinizde gerekli tüm Python paketlerini içe aktarın:

from google import genai
from google.genai import types
from pydantic import BaseModel
from langgraph.graph import StateGraph, END
import os, json, textwrap, traceback
from pathlib import Path
import pandas as pd
import markdown2
import weasyprint

6. LangSmith proje adını belirtmek ve LangSmith izlemeyi etkinleştirmek için ortam değişkenlerini ayarlayın:

os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = os.environ.get("LANGSMITH_API_KEY", "YOUR_LANGSMITH_KEY")
os.environ["LANGSMITH_PROJECT"] = os.environ.get("LANGSMITH_PROJECT", "autolab-gemini3pro")

7. Tüm görsellerin ve PDF’lerin kaydedileceği klasörü oluşturun:

ARTIFACTS_DIR = Path("artifacts")
ARTIFACTS_DIR.mkdir(exist_ok=True)

2. Gemini 3 API İstemcisi Nasıl Başlatılır

Bu bölümde, Gemini API istemcisini kuracak ve modele yapılan çağrıları LangSmith tarafından izlenip günlüğe kaydedilebilecek şekilde sarmalayacağız. Ayrıca, belirteç kullanımıyla ilgili meta verileri çıkaracak ve bunları LangSmith’e uygun bir formatta döndüreceğiz.

İlk olarak, API anahtarını sağlayarak Gemini GenAI istemcisini başlatacağız:

client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])
MODEL = "gemini-3-pro-preview"

Sonraki adımda, LangSmith tarafından otomatik izlemeyi etkinleştirmek için bir Gemini model çağrısının etrafına küçük bir sarmalayıcı yazacağız. @traceable dekoratörünü kullanarak, işlevi bir LLM çalıştırması olarak kaydederiz. 

Bu işlev içinde, kod istemi Gemini’ye gönderir ve izleme yönergelerine uygun olarak, doğru LangSmith takibi için gerekli olan belirteç kullanımı ayrıntılarını çıkarır. 

Son olarak işlev, modelin metin çıktısını belirteç istatistikleri ve ham yanıtla birlikte, çalıştırmanın arayüzde doğru görüntülenmesini sağlayan LangSmith’in beklediği formatta döndürür.

from langsmith import traceable
@traceable(name="gemini_generate_content", run_type="llm")
def gemini_call(prompt: str, thinking_level: str = "high"):
    """
    Gemini wrapper that:
    - uses correct ThinkingConfig schema
    - returns LangSmith LLM-run format so token usage shows in UI
    """
    resp = client.models.generate_content(
        model=MODEL,
        contents=prompt,
        config=types.GenerateContentConfig(
            thinking_config=types.ThinkingConfig(thinking_level=thinking_level)
        ),
    )

    usage = getattr(resp, "usage_metadata", None)
    token_usage = None
    if usage:
        token_usage = {
            "prompt_tokens": usage.prompt_token_count,
            "completion_tokens": usage.candidates_token_count,
            "total_tokens": usage.total_token_count,
            "thoughts_tokens": getattr(usage, "thoughts_token_count", None),
        }

    return {
        "generations": [{"text": resp.text}],
        "llm_output": {
            "model_name": MODEL,
            "token_usage": token_usage,
        },
        "raw_response": resp,
    }

3. Çoklu Ajanlı Gemini 3 İş Akışı için Araçlar Oluşturma

Şimdi, bir yapay zeka ajanı iş akışı içinde kullanılacak veri kümesi inceleme, güvenli Python çalıştırma ve Markdown’dan PDF’e rapor üretme araçlarını oluşturacağız.

Araç 1: Veri kümesini yükleyin

Bu araç bir dosya yolu alır, CSV’yi pandas DataFrame’ine okur ve ardından veri kümesinin boyutu, sütun adları, her sütunun veri türü, eksik değer yüzdeleri, ilk beş satır ve tam betimleyici istatistikleri içeren bir özet oluşturur. Ajanın veri kümesini hızlıca anlaması için bu özeti döndürür.

def load_dataset(path: str):
    df = pd.read_csv(path)

    summary = {
        "shape": df.shape,
        "columns": list(df.columns),
        "dtypes": {c: str(t) for c, t in df.dtypes.items()},
        "missing_pct": df.isna().mean().to_dict(),
        "head": df.head(5).to_dict(orient="records"),
        "describe": df.describe(include="all").fillna("").to_dict()
    }
    return summary

Araç 2: Python kodunu güvenli şekilde çalıştırın (basit sandbox)

Bu araç, dinamik olarak oluşturulan Python kodunu kısıtlı bir ortam içinde güvenle çalıştırır. Küçük bir yerel ortam hazırlar ve ardından verilen kodu exec ile yürütür. 

Çalıştırılan kodun, eser yollarını (kaydedilen grafikler gibi) ve meta verileri döndürmesi beklenir. 

def run_python(code: str):
    """
    Generated code MUST:
      - save plots to ARTIFACTS_DIR
      - collect paths in _artifacts (list[str])
      - collect meta in _charts_meta (list[dict])
      - optionally set _stdout (string)
    """
    local_env = {"ARTIFACTS_DIR": ARTIFACTS_DIR}
    try:
        exec(textwrap.dedent(code), {}, local_env)
        return {
            "ok": True,
            "stdout": local_env.get("_stdout", ""),
            "artifacts": local_env.get("_artifacts", []),
            "charts_meta": local_env.get("_charts_meta", []),
        }
    except Exception:
        return {"ok": False, "traceback": traceback.format_exc()}

Araç 3: Markdown’dan PDF üretin

Bu araç, Markdown’ı güzel biçimlendirilmiş bir PDF’e dönüştürür. Önce tablolar, listeler, görev listeleri ve dipnotları destekleyen bir markdown ayrıştırıcısı oluşturur. 

Ardından render_pdf, markdown metnini HTML’e dönüştürür, özel CSS stilli bir şablona (yazı tipleri, tablo görünümü, görsel boyutlandırma vb. kontrol edilerek) sarar ve WeasyPrint kullanarak bir PDF dosyası oluşturur. 

Son olarak PDF’yi artifacts klasörüne kaydeder ve yolunu döndürür.

from markdown_it import MarkdownIt
from mdit_py_plugins.tasklists import tasklists_plugin
from mdit_py_plugins.footnote import footnote_plugin

# Create a strong markdown parser once (supports tables, lists, etc.)
md = (
    MarkdownIt("commonmark", {"breaks": True, "html": True})
    .enable(["table", "strikethrough"])
    .use(tasklists_plugin)
    .use(footnote_plugin)
)

def render_pdf(markdown_text: str):
    """
    Better Markdown -> HTML -> PDF:
    - proper tables
    - stable lists
    - centered/small images
    - clean page breaks
    """
    html_body = md.render(markdown_text)

    html_template = f"""
    <html>
    <head>
      <meta charset="utf-8">
      <style>
        body {{
          font-family: Arial, sans-serif;
          font-size: 12px;
          line-height: 1.5;
          color: #111;
        }}

        h1 {{ font-size: 20px; margin-bottom: 6px; }}
        h2 {{ font-size: 16px; margin-top: 18px; margin-bottom: 6px; }}
        h3 {{ font-size: 13px; margin-top: 12px; margin-bottom: 4px; }}

        p {{ margin: 6px 0; }}

        ul, ol {{
          margin: 6px 0 6px 18px;
        }}
        li {{ margin: 2px 0; }}

        table {{
          width: 100%;
          border-collapse: collapse;
          margin: 8px 0 12px 0;
          font-size: 11px;
        }}
        th, td {{
          border: 1px solid #ccc;
          padding: 6px;
          text-align: left;
        }}
        th {{ background: #f2f2f2; }}

        img {{
          display: block;
          margin: 8px auto 8px auto;
          max-width: 70%;
          height: auto;
          page-break-inside: avoid;
        }}

        .chart-block {{
          page-break-inside: avoid;
          margin-bottom: 12px;
        }}

        code {{
          background: #f6f6f6;
          padding: 2px 4px;
          border-radius: 4px;
          font-size: 11px;
        }}
        pre code {{
          display: block;
          padding: 8px;
          overflow-x: auto;
        }}
      </style>
    </head>
    <body>
      {html_body}
    </body>
    </html>
    """

    pdf_path = ARTIFACTS_DIR / "report.pdf"
    weasyprint.HTML(
        string=html_template,
        base_url=str(ARTIFACTS_DIR.parent.resolve())
    ).write_pdf(str(pdf_path))

    return str(pdf_path)

Bu, yalnızca üç işlevin tamamını ajan tarafından kullanılabilir araçlar olarak kaydeder.

TOOLS = [load_dataset, run_python, render_pdf]

4. Paylaşılan Grafik (Graph) Durumu

Bu sınıf, ajanın iş akışının ürettiği her şeyi tutan paylaşılan bir state nesnesini tanımlar: veri kümesi yolu, profilleme bilgileri, oluşturulan plan, kod, yürütme sonuçları, içgörüler ve son rapor gibi; ayrıca sonsuz döngüleri önlemek için yeniden deneme sınırları ve hata iletileri.

class State(BaseModel):
    dataset_path: str
    profile: dict | None = None
    plan: dict | None = None
    code: str | None = None
    exec_result: dict | None = None
    charts_meta: list | None = None
    insights: str | None = None
    report_md: str | None = None
    report_pdf: str | None = None

    retry_count: int = 0          # NEW: stop infinite loops
    last_error: str | None = None # NEW: pass traceback to coder

MAX_RETRIES = 2

5. Veri Analizi için Gemini 3 API Ajanları Oluşturma

Şimdi, veri kümesini profillemek, analiz kodu yazıp çalıştırmak, içgörüler üretmek ve nihai bir PDF raporu oluşturmak için birlikte çalışacak yapay zeka ajanları oluşturacağız.

Ajan 1: Veri profilleyici ve planlayıcı

Bu ajan, veri kümesini anlamaktan ve yapılandırılmış bir analiz planı oluşturmaktan sorumludur. Önce load_dataset aracını kullanarak veri kümesini yükler; bu da şekiller, eksik değerler, sütun türleri, betimleyici istatistikler ve örnek satırlar içeren bir özet sunar. 

Ardından bu veri kümesi özetini, çok açık talimatlarla LLM’e gönderir: görev türünü belirleyin, uygulanabilirse bir hedef sütun seçin, hangi keşif adımlarının atılması gerektiğine karar verin, oluşturulması gereken grafikleri önerin ve veri kümesi sınıflandırma veya regresyonu öneriyorsa olası modelleme adımlarını özetleyin. 

LLM, bu planı temsil eden bir JSON yapı döndürür ve ajan, JSON ayrıştırma başarısız olursa ham metni saklamaya geri dönerek bunu ayrıştırır. 

Son olarak, hem veri kümesi profilini hem de oluşturulan planı, sonraki ajanların ihtiyaç duyduğu tüm bilgilere sahip olmasını sağlamak için paylaşılan duruma kaydeder.

@traceable(name="profiler_agent")
def profiler_agent(state: State):
    profile = load_dataset(state.dataset_path)

    prompt = f"""
    You are the Data Profiler Agent.
    Produce a JSON analysis plan with:
      - task_type: "classification"|"regression"|"eda_only"
      - target_column (if any)
      - eda_steps (list)
      - charts_to_make (list)  # 5-10 max, most informative
      - baseline_model_steps (list if modeling)
      - risks_or_data_issues (list)

    Dataset profile:
    {json.dumps(profile, indent=2)}
    """

    resp = gemini_call(prompt, thinking_level="high")
    text = resp["generations"][0]["text"]

    try:
        plan = json.loads(text)
    except:
        plan = {"raw_plan": text}

    state.profile = profile
    state.plan = plan
    return state

Ajan 2: Kod yazarı

Bu ajan, analiz planını çalıştırılabilir Python koduna dönüştürür. Veri kümesi profilini, planı ve önceki çalıştırma hatalarını alır. Tüm bu bağlamla, LLM’den yalnızca Python kodu üretmesini ister. 

İstem katı gereklilikler içerir: veri kümesini yükleyin, planı aynen takip edin, belirtilen her grafiği üretin, grafikleri ARTIFACTS_DIR içine kaydedin, yolları ve grafik meta verilerini takip edin, konsol çıktısını yakalayın, kaydettikten sonra figürleri kapatın ve isteğe bağlı olarak modelleme metriklerini hesaplayın. 

Bu, kodun sandbox içinde yeniden üretilebilir ve güvenli olmasını sağlar. Sonuç state.code değişkeninde saklanır ve yürütücü tarafından çalıştırılmaya hazırdır.

@traceable(name="code_writer_agent")
def code_writer_agent(state: State):
    prompt = f"""
    You are the Code Writer Agent.
    Write Python code ONLY (no markdown).

    Previous error to fix (if any):
    {state.last_error}

    HARD REQUIREMENTS:
    1. Load dataset from: {state.dataset_path}
    2. Follow the plan exactly.
    3. Create ALL charts in charts_to_make.
    4. Save every chart in ARTIFACTS_DIR with filenames like:
         ARTIFACTS_DIR / "chart_01_<short_name>.png"
    5. Track saved plot paths in _artifacts (list[str]).
    6. Track chart metadata in _charts_meta (list[dict]) with:
         {{
           "title": "<human readable chart title>",
           "filename": "artifacts/chart_01_x.png",
           "description": "<what this plot shows (1-2 sentences)>",
           "one_liner": "<ONE line insight from the chart>"
         }}
       The one_liner MUST be a single sentence, max ~20 words.

    7. Store useful console output in _stdout.

    IMPORTANT:
    - import matplotlib.pyplot as plt
    - plt.close() after saving each plot
    - ensure _artifacts and _charts_meta exist even if empty
    - if modeling, add baseline metrics to _stdout

    Dataset profile:
    {json.dumps(state.profile, indent=2)}

    Analysis plan:
    {json.dumps(state.plan, indent=2)}

    Return ONLY executable python code.
    """

    resp = gemini_call(prompt, thinking_level="high")
    state.code = resp["generations"][0]["text"]
    return state

Ajan 3: Yürütücü (otomatik yeniden denemeli)

Bu ajan, Kod Yazarı tarafından üretilen Python kodunu, izole run_python sandbox’ında çalıştırır. Çalıştırma sonuçlarını, grafik meta verilerini, standart çıktıyı ve oluşturulan eserleri yakalar. 

Kod başarıyla çalışırsa sonuçlar saklanır ve iş akışı normal şekilde ilerler. Başarısız olursa, ajan yeniden deneme sayacını artırır ve bir sonraki denemede hatayı düzeltmesi için Kod Yazarı ajanına izleği kaydeder. 

MAX_RETRIES döngüyü sınırladığından, bu ajan sonsuz döngüleri önler ve öz-düzeltme için gerekli geri bildirim sinyallerini sağlar.

@traceable(name="executor_agent")
def executor_agent(state: State):
    result = run_python(state.code)
    state.exec_result = result
    state.charts_meta = result.get("charts_meta", [])

    if not result["ok"]:
        state.retry_count += 1
        state.last_error = result.get("traceback", "Unknown error")

    return state

Ajan 4: İçgörü yazarı

Bu ajan, analizin tamamını yorumlar. Veri kümesi profilini, yürütme çıktısını ve grafik meta verilerini alır ve insan tarafından okunabilir analitik içgörüler üretir. 

LLM’i, her grafik için iki çıkarım ve bir risk üretmeye, ardından sınırlı sayıda genel içgörü oluşturmaya yönlendirir. 

Ajan, boş madde işaretleri olmamasını, tekrarlardan kaçınılmasını ve içgörülerin genel değil, veri kümesine özgü olmasını sağlamalıdır. 

Ortaya çıkan içgörü raporu state.insights içinde saklanır ve son raporlama aşaması için bir girdi haline gelir.

@traceable(name="insights_agent")
def insights_agent(state: State):
    prompt = f"""
    You are the Insights Agent.

    HARD REQUIREMENTS:
    - No empty bullets.
    - No repeated bullets.
    - Be specific to this dataset and these charts.
    - Output format:

      ### Chart Insights
      For each chart in charts_meta:
      - **<title>**
        - Takeaway 1 (one sentence)
        - Takeaway 2 (one sentence)
        - Caveat/Risk (one sentence)

      ### Overall Insights
      - 3-5 bullets max, each one sentence.

    Inputs:
    Profile:
    {json.dumps(state.profile, indent=2)}

    Execution result:
    {json.dumps(state.exec_result, indent=2)}

    Charts meta:
    {json.dumps(state.charts_meta, indent=2)}
    """

    resp = gemini_call(prompt, thinking_level="high")
    state.insights = resp["generations"][0]["text"]
    return state

Ajan 5: Rapor oluşturucu → PDF

Bu son sentez ajanıdır. Profil, içgörüler, grafik meta verileri, yürütme günlükleri gibi tüm hat çıktıları kullanılır ve tam, temiz bir Markdown raporu oluşturulur. 

İstem, sıkı biçimlendirme kuralları uygular: yinelenen başlıklar yok, tutarlı boşluklar, her grafik standartlaştırılmış bir HTML blokunda tam olarak bir kez gösterilir ve içgörüler temiz şekilde entegre edilir. 

Markdown üretildikten sonra, ajan WeasyPrint kullanarak parlatılmış bir PDF’e dönüştürmek için render_pdf çağrısı yapar. Hem Markdown hem de PDF yolu paylaşılan duruma kaydedilir ve analiz iş akışı tamamlanır.

@traceable(name="report_agent")
def report_agent(state: State):
    prompt = f"""
    You are the Report Agent.
    Create a neat Markdown report (HTML allowed).

    HARD REQUIREMENTS:
    - Do NOT repeat section titles or chart titles.
    - Do NOT output empty bullet points. If a bullet would be empty, skip it.
    - Keep spacing consistent: one blank line between sections.
    - Use charts_meta as the ONLY source of charts.
    - Include EVERY chart, exactly once, in the same order as charts_meta.
    - For each chart output EXACTLY this block:

      <div class="chart-block">
        <h3>Chart {{i}}: {{title}}</h3>
        <img src="{{filename}}" alt="{{title}}">
        <p><b>What it shows:</b> {{one_liner}}</p>
      </div>

      Where:
      - title, filename, one_liner come from charts_meta
      - one_liner must be ONE sentence, max ~20 words.

    Sections:
    1. Dataset Overview (short)
    2. Data Quality Notes (bullets)
    3. Exploratory Analysis (chart-by-chart blocks only, no extra chart titles)
    4. Modeling Results (if any; use a markdown table)
    5. Key Insights (use insights text)
    6. Recommendations / Next Steps (bullets)

    Inputs:
    Profile: {json.dumps(state.profile, indent=2)}
    Exec stdout: {state.exec_result.get("stdout","")}
    Exec ok: {state.exec_result.get("ok")}
    Traceback (if any): {state.exec_result.get("traceback","")}
    Charts meta:
    {json.dumps(state.charts_meta, indent=2)}
    Insights:
    {state.insights}

    Return ONLY the Markdown report.
    """

    resp = gemini_call(prompt, thinking_level="low")
    state.report_md = resp["generations"][0]["text"]
    state.report_pdf = render_pdf(state.report_md)
    return state

6. Çoklu Ajan Grafiğini Oluşturma

Bu son adım, tüm ajanları durum odaklı bir grafikte bir araya getirerek eksiksiz çoklu ajan iş akışını oluşturmaktır. 

Paylaşılan bir State modeli kullanılarak bir StateGraph oluşturulur; bu, iş akışı ilerledikçe her ajanın aynı gelişen durum nesnesiyle etkileşime girmesini sağlar. Profilleyici, kod yazarı, yürütücü, içgörü yazarı ve rapor oluşturucu gibi her bileşen, hattın belirli bir aşamasını temsil eden ayrı bir düğüm olarak grafiğe eklenir. 

İş akışı her zaman giriş noktası olarak belirlenen profilleyici ajan ile başlar. Bu, sürecin veri kümesinin kapsamlı şekilde anlaşılması ve bir analiz planının oluşturulmasıyla başlamasını sağlar.

Süreç akışını tanımlamak için kenarlar oluşturulur. Profillemeden sonra çıktı kod yazarına yönlendirilir; bu da yürütücüye beslenir. Ana mantık, yürütücüden yapılan koşullu yönlendirmededir. 

retry_or_continue adlı yardımcı işlev, yürütme sonucunu inceler. Kod başarıyla yürütülürse, iş akışı içgörü ajanına ilerler. 

Başarısız olursa ancak hâlâ yeniden deneme hakkı varsa, otomatik düzeltme için kod yazarına geri döner.

 Yeniden deneme kalmadıysa, daha fazla analizi atlayarak doğrudan rapor oluşturucuya geçer; böylece sistem sonsuz döngüye girmez. Koşullu kenarlar, yürütücü düğümüne dahil edilerek iş akışının, yürütmenin başarısına veya başarısızlığına göre uyarlanması sağlanır.

Son olarak, grafik içgörü aşamasını rapor aşamasına ve rapor aşamasını iş akışının sonuna bağlar. Grafik, yürütülebilir bir yapıya derlenir ve akışı görselleştirmek için bir ASCII diyagram üretilir. 

Bu çoklu ajan grafik, tüm uyarlanabilir analiz hattını düzenler; hata kurtarma, adım adım koordinasyon ve ajanlar arasında sorunsuz geçişler sağlar.

g = StateGraph(State)

g.add_node("profiler", profiler_agent)
g.add_node("code_writer", code_writer_agent)
g.add_node("executor", executor_agent)
g.add_node("insights", insights_agent)
g.add_node("report", report_agent)

g.set_entry_point("profiler")
g.add_edge("profiler", "code_writer")
g.add_edge("code_writer", "executor")

def retry_or_continue(state: State):
    # success path
    if state.exec_result and state.exec_result.get("ok"):
        return "insights"
    # stop retrying after MAX_RETRIES
    if state.retry_count >= MAX_RETRIES:
        return "report"
    return "code_writer"

g.add_conditional_edges(
    "executor",
    retry_or_continue,
    {"code_writer": "code_writer", "insights": "insights", "report": "report"}
)

g.add_edge("insights", "report")
g.add_edge("report", END)

graph = g.compile()

print(graph.get_graph().draw_ascii())

      +-----------+      
          | __start__ |      
          +-----------+      
                 *           
                 *           
                 *           
           +----------+      
           | profiler |      
           +----------+      
                 *           
                 *           
                 *           
          +-------------+    
          | code_writer |    
          +-------------+    
                 .           
                 .           
                 .           
           +----------+      
           | executor |      
           +----------+      
           ..         ..     
         ..             ..   
        .                 .. 
+----------+                .
| insights |              .. 
+----------+            ..   
           **         ..     
             **     ..       
               *   .         
            +--------+       
            | report |       
            +--------+       
                 *           
                 *           
                 *           
            +---------+      
            | __end__ |      
            +---------+  

7. Tüm Gemini 3 API Veri Analizi Hattını Çalıştırma

Tüm hattı çalıştırmak için yalnızca bir veri kümesi yolu sağlar, başlangıç State nesnesi oluşturur ve derlenen grafiği çağırırsınız. Bizim örneğimizde, Boston Housing veri kümesini sağlıyoruz.

DATASET_PATH = "/work/housing.csv"  # <-- change this

state = State(dataset_path=DATASET_PATH)
out = graph.invoke(state)

Çağrıldıktan sonra, çoklu ajan sistemi otomatik olarak tüm analizi gerçekleştirir: veri kümesini profilleme, bir plan oluşturma, Python kodu yazıp çalıştırma, içgörüler çıkarma ve hem bir Markdown hem de bir PDF rapor üretme.

--- Modeling Baseline Results ---
Dataset Shape: (489, 4)
Linear Regression -> RMSE: 82,395.54, R2: 0.6911
Random Forest     -> RMSE: 56,931.38, R2: 0.8525
Observations: Random Forest typically outperforms Linear Regression due to capturing non-linear relationships (e.g., LSTAT).

Çalışma tamamlandıktan sonra, LangSmith panonuzu açıp “autolab-gemini3pro” projesine gidebilirsiniz. Her ajan çalıştırması burada görünür. 

Son çalıştırmaya tıklayıp Şelale görünümüne geçmek, her adımın zaman çizelgesini gösterir: ajanların ne kadar süre aldığı ve hangi araçları kullandığı.

Herhangi bir ajana tıklayarak şunları inceleyebilirsiniz:

• Aldığı istem
• Tam model üretimi
• Araç çalıştırma ayrıntıları
• Döndürülen eserler, grafikler ve izler

LangSmith, tüm iş akışını iyileştirmede kritik rol oynadı. Gördüğünüz nihai sürüm, ancak bu projeyi doğru yapmak için birçok deneme gerekti ve LangSmith ajanlardaki sorunları hata ayıklamamda yardımcı oldu.

8. Rapor Markdown’ını ve PDF’i Görüntüleme

Çoklu ajan iş akışı tamamlandığında, oluşturulan Markdown raporunu doğrudan defteriniz içinde inceleyebilirsiniz. 

Markdown sürümü, analizi hızlıca gözden geçirmek, içgörüleri okumak ve çalışma alanınızdan ayrılmadan rapor yapısını incelemek için kullanışlıdır.

print(out["report_md"][:2000])

# Housing Price Analysis Report
## 1. Dataset Overview
The dataset consists of **489 records** and **4 features** focusing on housing metrics. The target variable is `MEDV` (Median Value of owner-occupied homes). The features include `RM` (average number of rooms), `LSTAT.............

Markdown’a ek olarak, iş akışı aynı zamanda parlatılmış bir PDF raporu da üretir. PDF, otomatik olarak artifacts klasörüne kaydedilir ve yolu şu şekilde görüntüleyebilirsiniz:

print("PDF saved at:", out["report_pdf"])

PDF saved at: artifacts/report.pdf

Oluşturulan PDF, analizin tüm temel bileşenlerini eksiksiz içerir: anlatı açıklamaları, görsel olarak render edilen grafikler, grafik yorumları, modelleme özetleri ve son öneriler. 

Bu, özellikle sonuçların temiz ve sunuma hazır bir sürümünü paylaşmak istediğinizde ekip arkadaşları, yöneticiler veya müşterilerle paylaşım için idealdir.

Son Düşünceler

Bu proje üzerinde çalışmak, modern yapay zeka modellerinin ve grafik tabanlı ajan iş akışlarının ne kadar geliştiğini açıkça gösterdi. Çok değil, kısa süre önce birden fazla araç içeren tek bir ajanı bile oluşturmak günler süren ayar, hata ayıklama ve öngörülemeyen davranışlarla uğraşmayı gerektiriyordu. 

Gemini 3 Pro gibi modellerle bugün, sistem veri kümesini anlayabiliyor, doğru kodu üretebiliyor, analizleri çalıştırabiliyor, görselleştirmeleri yorumlayabiliyor ve dikkat çekici bir güvenilirlikle özenli bir rapor derleyebiliyor. 

Bu projede, herhangi bir CSV veri kümesini alabilen, uçtan uca keşif analizi gerçekleştiren, temel modelleri çalıştıran, içgörüler üreten ve tamamen biçimlendirilmiş bir PDF raporu oluşturan eksiksiz bir çoklu ajan veri analizi uygulaması kurduk. 

Bu proje, profilleme ve planlama, kod üretimi, yeniden denemeli yürütme, içgörü üretimi ve raporlama olmak üzere beş koordineli ajan ve veri kümesi yükleme, güvenli kod yürütme ve Markdown’dan PDF’e dönüştürme için üç temel aracı kullanır. 

Sonuç, görselleştirmelerle desteklenen, profesyonel ve anlatı odaklı bir rapor üreten temiz, otomatik bir analiz akışıdır.