Tutorial API Gemini 3: Mengotomatiskan Analisis Data dengan Gemini 3 Pro dan LangGraph

Gemini 3 Pro adalah model AI tercanggih yang kita tunggu‑tunggu, dengan jendela konteks satu juta token yang mampu menangani dataset, dokumen, video, dan basis kode dalam sekali jalan. Model ini menghadirkan penalaran setingkat PhD sekaligus unggul dalam pemrosesan multimodal teks, gambar, audio, dan video untuk alur kerja kreatif yang mulus.

Dalam tutorial berbasis proyek ini, saya akan menunjukkan cara menggunakan Gemini 3 API untuk membangun aplikasi multi‑agen yang memakai dataset CSV dari pengguna dan melakukan analitik data mendalam. 

Singkatnya, aplikasi multi‑agen ini akan melakukan:

• Analitik sederhana: Mengeksplorasi struktur dan dasar‑dasar dataset dengan cepat.
• Pembuatan kode: Menggunakan Gemini 3 Pro untuk membuat kode analisis tingkat lanjut dengan visualisasi.
• Eksekusi aman: Menjalankan kode dalam lingkungan sandbox dan menyimpan hasilnya.
• Penalaran cerdas: Menganalisis dan menafsirkan temuan untuk insight kunci.
• Kompilasi laporan PDF: Menghasilkan PDF rapi dengan visual dan penjelasan yang jelas, insight dapat dipahami dalam hitungan detik.

Jika Anda ingin mempelajari lebih lanjut tentang membangun alur kerja AI agen, saya sarankan membaca panduan Google Antigravity, tutorial Gemini 3 Flash, dan jalur keterampilan AI Agent Fundamentals.

1. Menyiapkan Lingkungan Gemini 3 API

1. Jalankan perintah ini untuk memasang semua paket yang diperlukan untuk aplikasi multi‑agen kita:

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

Rincian Paket:

• google-generativeai: Mengakses Gemini 3 Pro melalui API resmi.
• langgraph: Mengorkestrasi alur kerja AI multi‑agen dengan mudah.
• langsmith: Melacak run, memantau performa, dan debug dengan dasbor interaktif.
• grandalf: Memvisualisasikan grafik agen sebagai diagram ASCII yang bersih.
• pydantic: Mengelola state grafik bersama dengan validasi data yang tangguh.
• pandas: Melakukan eksplorasi dan analisis dataset cepat.
• matplotlib: Menghasilkan visualisasi data yang memukau.
• markdown2: Mengonversi Markdown ke HTML untuk pemformatan laporan yang kaya.
• weasyprint: Mengubah HTML/CSS menjadi laporan PDF profesional.
• markdown-it-py: Parser Markdown tingkat lanjut untuk pemformatan kompleks.
• mdit-py-plugins: Memperluas markdown-it-py dengan plugin untuk tabel, catatan kaki, dan lainnya.

Catatan: Kita menggunakan Jupyter Notebook untuk membangun proyek ini.

2. Buka Google AI Studio dan buat kunci API Anda. Pastikan penagihan telah diaktifkan pada akun Anda, karena model Gemini 3 Pro tidak tersedia pada tier gratis. 

3. Selanjutnya, buat akun LangSmith gratis dan buat kunci API‑nya. 

4. Simpan kedua kunci API sebagai variabel lingkungan di sistem lokal Anda. Atur LANGSMITH_API_KEY dan GEMINI_API_KEY.

5. Impor semua paket Python yang diperlukan ke dalam notebook Anda:

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. Atur variabel lingkungan untuk menentukan nama proyek LangSmith dan mengaktifkan pelacakan LangSmith:

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. Buat folder tempat semua gambar dan PDF akan disimpan:

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

2. Cara Menginisialisasi Klien Gemini 3 API

Pada bagian ini, kita akan menyiapkan klien Gemini API dan membungkus pemanggilan model agar dapat ditelusuri dan dicatat di LangSmith. Selain itu, kita akan mengekstrak metadata penggunaan token dan mengembalikannya dalam format yang ramah LangSmith.

Pertama, kita akan menginisialisasi klien Gemini GenAI dengan menyediakan kunci API:

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

Selanjutnya, kita akan menulis pembungkus kecil di sekitar pemanggilan model Gemini untuk mengaktifkan penelusuran otomatis oleh LangSmith. Dengan dekorator @traceable, kita mendaftarkan fungsi sebagai run LLM. 

Di dalam fungsi ini, kode akan mengirim prompt ke Gemini dan mengekstrak detail penggunaan token, yang penting untuk pelacakan LangSmith yang akurat, mengikuti pedoman tracing. 

Terakhir, fungsi akan mengembalikan keluaran teks model beserta statistik token dan respons mentah dalam format yang diharapkan LangSmith, memastikan run ditampilkan dengan benar di UI.

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. Membangun Tools untuk Alur Kerja Multi‑Agen Gemini 3

Sekarang kita akan membuat tools yang menyediakan inspeksi dataset, eksekusi Python yang aman, dan pembuatan laporan Markdown‑ke‑PDF yang akan digunakan di dalam alur kerja agen AI.

Tool 1: Memuat dataset

Tool ini menerima path file, membaca CSV ke dalam pandas DataFrame, lalu membangun ringkasan berisi bentuk dataset, nama kolom, tipe data tiap kolom, persentase nilai hilang, lima baris pertama, dan statistik deskriptif lengkap. Tool ini mengembalikan ringkasan agar agen cepat memahami dataset.

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

Tool 2: Menjalankan kode Python dengan aman (sandbox sederhana)

Tool ini menjalankan kode Python yang dihasilkan secara dinamis di dalam lingkungan terbatas dengan aman. Ia menyiapkan lingkungan lokal kecil, lalu mengeksekusi kode yang diberikan dengan exec. 

Kode yang dijalankan diharapkan mengembalikan path artefak (seperti plot yang disimpan) dan metadata. 

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()}

Tool 3: Merender PDF dari Markdown

Tool ini mengonversi Markdown menjadi PDF yang diformat dengan baik. Pertama ia membangun parser markdown yang mendukung tabel, daftar, daftar tugas, dan catatan kaki. 

Lalu render_pdf mengonversi teks markdown menjadi HTML, membungkusnya dalam templat ber‑CSS kustom (mengatur font, tampilan tabel, ukuran gambar, dll.), dan menggunakan WeasyPrint untuk menghasilkan file PDF. 

Terakhir, ia menyimpan PDF ke folder artefak dan mengembalikan path‑nya.

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)

Ini sekadar mendaftarkan ketiga fungsi sebagai tools yang tersedia untuk digunakan agen.

TOOLS = [load_dataset, run_python, render_pdf]

4. State Grafik Bersama

Kelas ini mendefinisikan objek state bersama yang menampung semua yang dihasilkan alur kerja agen: seperti path dataset, info profil, rencana yang dibuat, kode, hasil eksekusi, insight, dan laporan akhir, plus batas percobaan ulang dan pesan kesalahan untuk mencegah loop tak berujung.

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. Membuat Agen Gemini 3 API untuk Analisis Data

Sekarang kita akan membuat agen AI yang bekerja sama untuk memprofilkan dataset, menulis dan mengeksekusi kode analisis, menghasilkan insight, dan membuat laporan PDF akhir.

Agen 1: Profiler data dan perencana

Agen ini bertanggung jawab memahami dataset dan membuat rencana analisis terstruktur. Ia pertama‑tama memuat dataset menggunakan tool load_dataset, yang memberinya ringkasan berisi bentuk, nilai hilang, tipe kolom, statistik deskriptif, dan contoh baris. 

Kemudian ia mengirim ringkasan dataset ini ke LLM dengan instruksi yang sangat eksplisit: identifikasi jenis tugas, pilih kolom target jika relevan, tentukan langkah eksplorasi yang perlu dilakukan, usulkan grafik yang harus dibuat, dan garisbesar langkah pemodelan jika dataset menyarankan klasifikasi atau regresi. 

LLM mengembalikan struktur JSON yang merepresentasikan rencana ini, dan agen memparsingnya, dengan fallback menyimpan teks mentah jika parsing JSON gagal. 

Terakhir, ia menyimpan profil dataset dan rencana yang dihasilkan ke dalam state bersama agar agen berikutnya memiliki semua informasi yang dibutuhkan.

@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

Agen 2: Penulis kode

Agen ini mengonversi rencana analisis menjadi kode Python yang dapat dijalankan. Ia menerima profil dataset, rencana, dan kesalahan eksekusi sebelumnya. Dengan seluruh konteks itu, ia meminta LLM untuk menghasilkan hanya kode Python. 

Prompt mencakup persyaratan ketat: memuat dataset, mengikuti rencana secara persis, membuat setiap grafik yang ditentukan, menyimpan plot ke ARTIFACTS_DIR, melacak path dan metadata grafik, menangkap output konsol, menutup figur setelah menyimpan, dan opsional menghitung metrik pemodelan. 

Ini memastikan kode dapat direproduksi dan aman di sandbox. Hasilnya disimpan pada state.code, siap dijalankan oleh eksekutor.

@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

Agen 3: Eksekutor (dengan percobaan ulang otomatis)

Agen ini menjalankan kode Python yang dibuat oleh Penulis Kode menggunakan sandbox run_python yang terisolasi. Ia menangkap hasil eksekusi, metadata grafik, keluaran standar, dan artefak apa pun yang dibuat. 

Jika kode berjalan sukses, hasil disimpan dan alur kerja berlanjut seperti biasa. Jika gagal, agen menambah penghitung percobaan ulang dan menyimpan traceback agar agen Penulis Kode dapat memperbaiki kesalahan pada upaya berikutnya. 

Dengan MAX_RETRIES yang membatasi loop, agen ini mencegah siklus tak berujung dan menyediakan sinyal umpan balik yang diperlukan untuk koreksi mandiri.

@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

Agen 4: Penulis insight

Agen ini menafsirkan seluruh analisis. Ia mengambil profil dataset, keluaran eksekusi, dan metadata grafik, lalu menghasilkan insight analitis yang mudah dibaca manusia. 

Ia menginstruksikan LLM untuk menghasilkan insight terstruktur: untuk setiap grafik, berikan dua takeaway dan satu risiko, lalu buat sejumlah insight keseluruhan yang terbatas. 

Agen harus memastikan tidak ada bullet kosong, tidak ada pengulangan poin, dan insight harus spesifik untuk dataset, bukan generik. 

Laporan insight yang dihasilkan disimpan di state.insights, menjadi masukan untuk tahap pelaporan akhir.

@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

Agen 5: Pembuat laporan → PDF

Ini adalah agen sintesis terakhir. Ia menggunakan keluaran lengkap pipeline: profil, insight, metadata grafik, log eksekusi, dan menyusun laporan Markdown penuh yang rapi. 

Prompt menerapkan aturan pemformatan ketat: tidak mengulang judul, spasi konsisten, setiap grafik ditampilkan tepat sekali dalam blok HTML standar, dan insight diintegrasikan dengan rapi. 

Setelah Markdown dihasilkan, agen memanggil render_pdf untuk mengonversinya menjadi PDF yang dipoles menggunakan WeasyPrint. Baik Markdown maupun path PDF disimpan di state bersama, melengkapi alur analisis.

@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. Membangun Grafik Multi‑Agen

Langkah terakhir ini mencakup membangun alur kerja multi‑agen lengkap dengan merangkai semua agen ke dalam grafik berbasis state. 

StateGraph dibuat menggunakan model State bersama, memastikan setiap agen berinteraksi dengan objek state yang berkembang seiring kemajuan alur kerja. Setiap komponen, seperti profiler, penulis kode, eksekutor, penulis insight, dan pembuat laporan, ditambahkan ke grafik sebagai node terpisah yang mewakili tahap tertentu dalam pipeline. 

Alur kerja selalu dimulai dengan agen profiler, yang ditetapkan sebagai titik masuk. Ini memastikan proses dimulai dengan pemahaman menyeluruh tentang dataset dan pembuatan rencana analisis.

Edge ditetapkan untuk mendefinisikan aliran proses. Setelah profiling, output diarahkan ke penulis kode, yang kemudian diteruskan ke eksekutor. Logika kunci terletak pada perutean kondisional dari eksekutor. 

Fungsi pembantu, retry_or_continue, memeriksa hasil eksekusi. Jika kode dieksekusi dengan sukses, alur kerja berlanjut ke agen insight. 

Jika gagal tetapi masih memiliki jatah percobaan, alur berputar kembali ke penulis kode untuk koreksi otomatis.

 Jika tidak ada percobaan tersisa, ia melewati analisis lebih lanjut dan langsung menuju pembuat laporan, memastikan sistem tidak masuk ke loop tak berujung. Edge kondisional dimasukkan ke node eksekutor agar alur kerja dapat beradaptasi berdasarkan keberhasilan atau kegagalan eksekusi.

Terakhir, grafik menghubungkan tahap insight ke tahap laporan, dan dari tahap laporan ke penutup alur kerja. Grafik kemudian dikompilasi menjadi struktur yang dapat dieksekusi, dan diagram ASCII dibuat untuk memvisualisasikan alur. 

Grafik multi‑agen ini mengorkestrasi seluruh pipeline analisis adaptif, memungkinkan pemulihan kesalahan, koordinasi bertahap, dan transisi mulus antaragen.

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. Menjalankan Pipeline Analisis Data Penuh Gemini 3 API

Untuk menjalankan pipeline penuh, Anda cukup menyediakan path dataset, membuat objek State awal, dan memanggil grafik yang telah dikompilasi. Dalam contoh ini, kita memberinya dataset Boston Housing.

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

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

Setelah dipanggil, sistem multi‑agen secara otomatis melakukan seluruh analisis: memprofilkan dataset, membuat rencana, menulis dan mengeksekusi kode Python, mengekstrak insight, serta menghasilkan laporan Markdown dan PDF.

--- 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).

Setelah run selesai, Anda dapat membuka dasbor LangSmith dan menavigasi ke proyek “autolab-gemini3pro”. Setiap run agen muncul di sana. 

Mengklik run terbaru dan beralih ke tampilan Waterfall akan menampilkan linimasa setiap langkah: berapa lama waktu yang dibutuhkan agen dan tools apa yang mereka gunakan.

Anda dapat mengeklik salah satu agen untuk memeriksa:

• Prompt yang diterima
• Generasi model yang persis
• Detail eksekusi tool
• Artefak, grafik, dan trace yang dikembalikan

LangSmith sangat berperan dalam meningkatkan seluruh alur kerja. Yang Anda lihat adalah versi final, tetapi dibutuhkan banyak percobaan untuk menyempurnakan proyek ini, dan LangSmith membantu saya men‑debug masalah pada agen.

8. Menampilkan Markdown dan PDF Laporan

Setelah alur kerja multi‑agen selesai, Anda dapat langsung memeriksa laporan Markdown yang dihasilkan di dalam notebook Anda. 

Versi Markdown berguna untuk meninjau analisis dengan cepat, membaca insight, dan memeriksa struktur laporan tanpa meninggalkan workspace Anda.

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.............

Selain Markdown, alur kerja juga menghasilkan laporan PDF yang dipoles. PDF disimpan otomatis di folder artefak, dan Anda dapat melihat path‑nya seperti ini:

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

PDF saved at: artifacts/report.pdf

PDF yang dihasilkan sudah sangat baik dan mencakup semua komponen kunci analisis: penjelasan naratif, grafik yang dirender, interpretasi grafik, ringkasan pemodelan, dan rekomendasi akhir. 

Ini ideal untuk dibagikan kepada rekan tim, atasan, atau klien, terutama saat Anda membutuhkan versi hasil yang rapi dan siap presentasi.

Penutup

Mengerjakan proyek ini membuat jelas seberapa jauh model AI modern dan alur kerja agen berbasis grafik telah berkembang. Dulu, membangun satu agen dengan beberapa tools saja membutuhkan berhari‑hari penyetelan, debugging, dan menghadapi perilaku yang tidak terduga. 

Kini, dengan model seperti Gemini 3 Pro, sistem dapat memahami dataset, menghasilkan kode yang akurat, menjalankan analisis, menafsirkan visualisasi, dan merangkai laporan yang rapi dengan keandalan yang mengesankan. 

Dalam proyek ini, kita membangun aplikasi analisis data multi‑agen lengkap yang mampu menerima dataset CSV apa pun, melakukan analisis eksploratori end‑to‑end, menjalankan model baseline, menghasilkan insight, dan membuat laporan PDF yang diformat penuh. 

Proyek ini menggunakan lima agen yang terkoordinasi: profiling & perencanaan, pembuatan kode, eksekusi dengan percobaan ulang, pembuatan insight, dan pelaporan, serta tiga tool inti untuk pemanggilan dataset, eksekusi kode yang aman, dan perenderan Markdown‑ke‑PDF. 

Hasilnya adalah alur analisis otomatis yang bersih yang menghasilkan laporan profesional berbasis narasi yang didukung visualisasi.