Tutorial ScrapeGraphAI: Web Scraping Cerdas dengan LLM dan Graph Logic

# Tutorial ScrapeGraphAI: Web Scraping Cerdas dengan LLM dan Graph Logic ## Pendahuluan Web scraping adalah salah satu teknik paling penting dalam dunia data engineering dan data science. Namun, scr...

By Ruby Abdullah · · tutorial
ScrapeGraphAIWeb ScrapingLLMPythonData Engineering

Tutorial ScrapeGraphAI: Web Scraping Cerdas dengan LLM dan Graph Logic

Pendahuluan

Web scraping adalah salah satu teknik paling penting dalam dunia data engineering dan data science. Namun, scraping tradisional memiliki banyak keterbatasan: script yang mudah rusak ketika struktur HTML berubah, kesulitan mengekstrak data dari halaman dinamis, dan kebutuhan untuk menulis parser yang spesifik untuk setiap website.

ScrapeGraphAI hadir sebagai solusi modern yang menggabungkan kekuatan Large Language Models (LLM) dengan graph-based pipeline untuk web scraping. Dengan ScrapeGraphAI, Anda cukup mendeskripsikan data apa yang ingin diekstrak dalam bahasa natural, dan library ini akan secara otomatis menavigasi halaman web, memahami strukturnya, dan mengekstrak informasi yang diminta.

Library ini mendukung berbagai provider LLM termasuk OpenAI, Anthropic Claude, Google Gemini, Ollama untuk model lokal, dan banyak lagi. ScrapeGraphAI juga menyediakan beberapa jenis graph pipeline yang bisa disesuaikan dengan kebutuhan scraping Anda.

Dalam tutorial ini, kita akan mempelajari cara menginstal, mengonfigurasi, dan menggunakan ScrapeGraphAI untuk berbagai skenario scraping mulai dari yang sederhana hingga yang kompleks.

Instalasi

Prasyarat

Pastikan Anda sudah memiliki Python 3.9 atau lebih baru terinstal di sistem Anda. ScrapeGraphAI juga membutuhkan beberapa dependensi sistem.

Instalasi Dasar

pip install scrapegraphai

Instalasi dengan Dukungan Browser (untuk halaman dinamis)

pip install scrapegraphai[browsers]

playwright install chromium

Instalasi dengan Dukungan Model Lokal

Jika Anda ingin menggunakan model lokal melalui Ollama:

pip install scrapegraphai[local]

Pastikan Ollama sudah terinstal dan model yang diinginkan sudah di-download:

ollama pull llama3.1

ollama pull nomic-embed-text

Instalasi Lengkap

Untuk menginstal semua dependensi opsional:

pip install scrapegraphai[all]

Verifikasi Instalasi

import scrapegraphai

print(scrapegraphai.version)

Konsep Dasar

Arsitektur Graph Pipeline

ScrapeGraphAI bekerja dengan konsep graph pipeline. Setiap operasi scraping direpresentasikan sebagai sebuah graph yang terdiri dari beberapa node:

  • FetchNode: Mengambil konten dari URL atau input teks
  • ParseNode: Memproses dan membersihkan HTML
  • RAGNode: Menggunakan Retrieval-Augmented Generation untuk konteks
  • GenerateAnswerNode: Menggunakan LLM untuk mengekstrak data sesuai prompt
  • MergeAnswerNode: Menggabungkan hasil dari multiple sources
  • Jenis-Jenis Graph

    ScrapeGraphAI menyediakan beberapa graph bawaan:

    • SmartScraperGraph: Scraping satu halaman dengan prompt natural language
    • SearchGraph: Mencari di web terlebih dahulu, lalu scraping hasilnya
    • SpeechGraph: Scraping dan konversi hasil ke audio
    • ScriptCreatorGraph: Generate script scraping Python dari prompt
    • SmartScraperMultiGraph: Scraping beberapa URL sekaligus

    Basic Usage

    Konfigurasi dengan OpenAI

    from scrapegraphai.graphs import SmartScraperGraph
    
    

    graphconfig = {

    "llm": {

    "apikey": "sk-your-openai-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "verbose": True,

    "headless": True,

    }

    smartscraper = SmartScraperGraph(

    prompt="Ekstrak semua judul artikel dan deskripsinya",

    source="https://example.com/blog",

    config=graphconfig,

    )

    result = smartscraper.run()

    print(result)

    Konfigurasi dengan Anthropic Claude

    from scrapegraphai.graphs import SmartScraperGraph
    
    

    graphconfig = {

    "llm": {

    "apikey": "sk-ant-your-anthropic-key",

    "model": "anthropic/claude-sonnet-4-20250514",

    },

    "verbose": True,

    "headless": True,

    }

    smartscraper = SmartScraperGraph(

    prompt="Ambil daftar produk beserta harga dan rating",

    source="https://example.com/products",

    config=graphconfig,

    )

    result = smartscraper.run()

    print(result)

    Konfigurasi dengan Model Lokal (Ollama)

    from scrapegraphai.graphs import SmartScraperGraph
    
    

    graphconfig = {

    "llm": {

    "model": "ollama/llama3.1",

    "temperature": 0,

    "baseurl": "http://localhost:11434",

    },

    "embeddings": {

    "model": "ollama/nomic-embed-text",

    "baseurl": "http://localhost:11434",

    },

    "verbose": True,

    "headless": True,

    }

    smartscraper = SmartScraperGraph(

    prompt="Ekstrak semua nama perusahaan dan alamatnya",

    source="https://example.com/directory",

    config=graphconfig,

    )

    result = smartscraper.run()

    print(result)

    Scraping dari Teks atau HTML Lokal

    ScrapeGraphAI tidak hanya bisa scraping dari URL, tetapi juga dari teks atau file HTML lokal:

    from scrapegraphai.graphs import SmartScraperGraph
    
    

    htmlcontent = """

    Laptop Gaming X1

    Rp 15.000.000

    RAM 16GB, SSD 512GB, RTX 4060

    Laptop Ultrabook Y2

    Rp 12.000.000

    RAM 8GB, SSD 256GB, Intel Iris

    """

    graphconfig = {

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    }

    smartscraper = SmartScraperGraph(

    prompt="Ekstrak nama laptop, harga, dan spesifikasinya dalam format JSON",

    source=htmlcontent,

    config=graphconfig,

    )

    result = smartscraper.run()

    print(result)

    Output yang dihasilkan:

    {
    

    "products": [

    {

    "name": "Laptop Gaming X1",

    "price": "Rp 15.000.000",

    "specs": "RAM 16GB, SSD 512GB, RTX 4060"

    },

    {

    "name": "Laptop Ultrabook Y2",

    "price": "Rp 12.000.000",

    "specs": "RAM 8GB, SSD 256GB, Intel Iris"

    }

    ]

    }

    Advanced Usage

    Menggunakan Output Schema dengan Pydantic

    Untuk mendapatkan output yang terstruktur dan konsisten, Anda bisa mendefinisikan schema menggunakan Pydantic:

    from pydantic import BaseModel, Field
    

    from typing import List

    from scrapegraphai.graphs import SmartScraperGraph

    class Article(BaseModel):

    title: str = Field(description="Judul artikel")

    author: str = Field(description="Nama penulis")

    date: str = Field(description="Tanggal publikasi")

    summary: str = Field(description="Ringkasan artikel")

    class ArticleList(BaseModel):

    articles: List[Article] = Field(description="Daftar artikel")

    graphconfig = {

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "verbose": True,

    }

    smartscraper = SmartScraperGraph(

    prompt="Ekstrak semua artikel dari halaman ini",

    source="https://example.com/news",

    config=graphconfig,

    schema=ArticleList,

    )

    result = smartscraper.run()

    for article in result.get("articles", []):

    print(f"Judul: {article['title']}")

    print(f"Penulis: {article['author']}")

    print(f"Tanggal: {article['date']}")

    print(f"Ringkasan: {article['summary']}")

    print("---")

    Multi-URL Scraping

    Untuk scraping beberapa URL sekaligus:

    from scrapegraphai.graphs import SmartScraperMultiGraph
    
    

    graphconfig = {

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "verbose": True,

    "headless": True,

    }

    urls = [

    "https://example.com/page1",

    "https://example.com/page2",

    "https://example.com/page3",

    ]

    multiscraper = SmartScraperMultiGraph(

    prompt="Ekstrak judul halaman dan semua link yang ada",

    source=urls,

    config=graphconfig,

    )

    result = multiscraper.run()

    print(result)

    SearchGraph: Pencarian Web + Scraping

    SearchGraph menggabungkan pencarian web dengan scraping. Anda memberikan query pencarian, dan ScrapeGraphAI akan mencari di web, mengambil halaman-halaman yang relevan, lalu mengekstrak informasi:

    from scrapegraphai.graphs import SearchGraph
    
    

    graphconfig = {

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "maxresults": 5,

    "verbose": True,

    }

    searchscraper = SearchGraph(

    prompt="Apa saja framework Python terpopuler untuk machine learning di 2026?",

    config=graphconfig,

    )

    result = searchscraper.run()

    print(result)

    ScriptCreatorGraph: Generate Script Scraping

    Jika Anda ingin mendapatkan script Python yang bisa dijalankan ulang tanpa LLM:

    from scrapegraphai.graphs import ScriptCreatorGraph
    
    

    graphconfig = {

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "verbose": True,

    "library": "beautifulsoup",

    }

    scriptcreator = ScriptCreatorGraph(

    prompt="Buat script untuk mengekstrak semua judul berita dan linknya",

    source="https://example.com/news",

    config=graphconfig,

    )

    result = scriptcreator.run()

    print(result)

    Output berupa script Python yang menggunakan BeautifulSoup atau library scraping tradisional lainnya.

    Konfigurasi Proxy dan Rate Limiting

    Untuk scraping yang lebih aman dan menghormati rate limit:

    graphconfig = {
    

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "loaderkwargs": {

    "proxy": {

    "server": "http://proxy-server:8080",

    "username": "user",

    "password": "pass",

    },

    },

    "verbose": True,

    "headless": True,

    }

    Menangani Halaman Dinamis dengan JavaScript

    Untuk halaman yang membutuhkan JavaScript rendering:

    graphconfig = {
    

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "headless": True,

    "browsertype": "chromium",

    "loaderkwargs": {

    "waituntil": "networkidle",

    "timeout": 30000,

    },

    "verbose": True,

    }

    smartscraper = SmartScraperGraph(

    prompt="Ekstrak data dari tabel yang dimuat secara dinamis",

    source="https://example.com/dynamic-table",

    config=graphconfig,

    )

    result = smartscraper.run()

    Custom Graph Pipeline

    Anda bisa membuat pipeline graph kustom untuk kebutuhan scraping yang lebih kompleks:

    from scrapegraphai.graphs import BaseGraph
    

    from scrapegraphai.nodes import FetchNode, ParseNode, GenerateAnswerNode

    class CustomScraperGraph(BaseGraph):

    def init(self, prompt, source, config):

    self.prompt = prompt

    self.source = source

    self.config = config

    fetchnode = FetchNode(

    input="url | localdir",

    output=["doc"],

    nodeconfig={"verbose": config.get("verbose", False)},

    )

    parsenode = ParseNode(

    input="doc",

    output=["parseddoc"],

    nodeconfig={"chunksize": 4096},

    )

    generatenode = GenerateAnswerNode(

    input="userprompt & parseddoc",

    output=["answer"],

    nodeconfig={

    "llmmodel": config["llm"],

    "verbose": config.get("verbose", False),

    },

    )

    super().init(

    nodes=[fetchnode, parsenode, generatenode],

    edges=[

    (fetchnode, parsenode),

    (parsenode, generatenode),

    ],

    entrypoint=fetchnode,

    )

    Contoh Proyek: Scraping Job Listings

    Berikut contoh proyek lengkap untuk scraping lowongan kerja:

    import json
    

    from pydantic import BaseModel, Field

    from typing import List, Optional

    from scrapegraphai.graphs import SmartScraperGraph

    class JobListing(BaseModel):

    title: str = Field(description="Judul posisi")

    company: str = Field(description="Nama perusahaan")

    location: str = Field(description="Lokasi kerja")

    salary: Optional[str] = Field(description="Range gaji jika tersedia")

    requirements: List[str] = Field(description="Daftar persyaratan")

    jobtype: str = Field(description="Tipe pekerjaan: remote/onsite/hybrid")

    class JobListingResult(BaseModel):

    jobs: List[JobListing] = Field(description="Daftar lowongan kerja")

    graphconfig = {

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "verbose": True,

    "headless": True,

    }

    scraper = SmartScraperGraph(

    prompt="""

    Ekstrak semua lowongan kerja dari halaman ini.

    Untuk setiap lowongan, ambil judul posisi, nama perusahaan,

    lokasi, range gaji (jika ada), persyaratan utama,

    dan tipe pekerjaan (remote/onsite/hybrid).

    """,

    source="https://example.com/jobs",

    config=graphconfig,

    schema=JobListingResult,

    )

    result = scraper.run()

    with open("joblistings.json", "w", encoding="utf-8") as f:

    json.dump(result, f, indent=2, ensureascii=False)

    print(f"Berhasil mengekstrak {len(result.get('jobs', []))} lowongan kerja")

    Contoh Proyek: Monitoring Harga E-Commerce

    import json
    

    from datetime import datetime

    from pydantic import BaseModel, Field

    from typing import List, Optional

    from scrapegraphai.graphs import SmartScraperMultiGraph

    class Product(BaseModel):

    name: str = Field(description="Nama produk")

    price: str = Field(description="Harga produk")

    originalprice: Optional[str] = Field(description="Harga asli sebelum diskon")

    discount: Optional[str] = Field(description="Persentase diskon")

    rating: Optional[str] = Field(description="Rating produk")

    soldcount: Optional[str] = Field(description="Jumlah terjual")

    class ProductList(BaseModel):

    products: List[Product] = Field(description="Daftar produk")

    graphconfig = {

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "verbose": True,

    "headless": True,

    }

    categories = [

    "https://example-shop.com/laptops",

    "https://example-shop.com/phones",

    "https://example-shop.com/tablets",

    ]

    multiscraper = SmartScraperMultiGraph(

    prompt="""

    Ekstrak semua produk dari halaman ini termasuk

    nama, harga saat ini, harga asli, diskon, rating,

    dan jumlah terjual.

    """,

    source=categories,

    config=graphconfig,

    schema=ProductList,

    )

    result = multiscraper.run()

    timestamp = datetime.now().isoformat()

    output = {

    "scrapedat": timestamp,

    "data": result,

    }

    with open(f"prices{datetime.now().strftime('%Y%m%d')}.json", "w") as f:

    json.dump(output, f, indent=2, ensureascii=False)

    print(f"Data harga berhasil disimpan pada {timestamp}")

    Best Practices

    1. Pilih Model yang Tepat

    Untuk scraping sederhana, model kecil seperti gpt-4o-mini sudah cukup dan lebih hemat biaya. Gunakan model yang lebih besar seperti gpt-4o atau claude-sonnet hanya untuk halaman yang kompleks atau ketika akurasi sangat penting.

    2. Gunakan Schema Pydantic

    Selalu definisikan output schema dengan Pydantic untuk mendapatkan hasil yang konsisten dan terstruktur. Ini juga membantu LLM memahami format output yang diharapkan.

    3. Tulis Prompt yang Spesifik

    Prompt yang terlalu umum seperti "ambil semua data" akan menghasilkan output yang tidak konsisten. Sebutkan secara spesifik data apa yang ingin diekstrak.

    # Kurang baik
    

    prompt = "Ambil semua informasi dari halaman ini"

    Lebih baik

    prompt = "Ekstrak nama produk, harga dalam Rupiah, dan rating bintang (1-5) dari setiap item produk"

    4. Tangani Error dengan Baik

    from scrapegraphai.graphs import SmartScraperGraph
    
    

    try:

    scraper = SmartScraperGraph(

    prompt="Ekstrak data produk",

    source="https://example.com/products",

    config=graphconfig,

    )

    result = scraper.run()

    if result:

    print("Scraping berhasil:", result)

    else:

    print("Tidak ada data yang ditemukan")

    except Exception as e:

    print(f"Error saat scraping: {e}")

    5. Hormati Rate Limit dan robots.txt

    Selalu perhatikan rate limit website yang Anda scrape. Tambahkan delay antar request jika perlu, dan periksa robots.txt sebelum scraping.

    6. Gunakan Model Lokal untuk Volume Tinggi

    Jika Anda perlu melakukan scraping dalam volume besar, pertimbangkan untuk menggunakan model lokal melalui Ollama. Ini akan menghemat biaya API secara drastis.

    7. Cache Hasil Scraping

    Untuk menghindari request berulang ke website yang sama:

    import json
    

    import hashlib

    import os

    def scrapewithcache(prompt, url, config, cachedir="cache"):

    os.makedirs(cachedir, existok=True)

    cachekey = hashlib.md5(f"{prompt}{url}".encode()).hexdigest()

    cachefile = os.path.join(cachedir, f"{cachekey}.json")

    if os.path.exists(cachefile):

    with open(cachefile, "r") as f:

    return json.load(f)

    scraper = SmartScraperGraph(

    prompt=prompt,

    source=url,

    config=config,

    )

    result = scraper.run()

    with open(cachefile, "w") as f:

    json.dump(result, f, indent=2)

    return result

    8. Logging dan Monitoring

    Aktifkan verbose mode selama development untuk memahami alur pipeline:

    graphconfig = {
    

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "verbose": True,

    }

    Perbandingan dengan Library Scraping Lainnya

    | Fitur | ScrapeGraphAI | BeautifulSoup | Scrapy | Selenium |

    |-------|--------------|---------------|--------|----------|

    | Natural Language Prompt | Ya | Tidak | Tidak | Tidak |

    | Tanpa Menulis Selector | Ya | Tidak | Tidak | Tidak |

    | Halaman Dinamis | Ya | Tidak | Plugin | Ya |

    | Structured Output | Ya (Pydantic) | Manual | Manual | Manual |

    | Multi-LLM Support | Ya | N/A | N/A | N/A |

    | Model Lokal | Ya (Ollama) | N/A | N/A | N/A |

    | Biaya per Request | Ada (LLM) | Gratis | Gratis | Gratis |

    | Kecepatan | Sedang | Cepat | Cepat | Lambat |

    Troubleshooting

    Error: Model Not Found

    Pastikan format model menggunakan prefix provider:

    # Benar
    

    "model": "openai/gpt-4o-mini"

    "model": "anthropic/claude-sonnet-4-20250514"

    "model": "ollama/llama3.1"

    Salah

    "model": "gpt-4o-mini"

    Error: Playwright Not Installed

    Jika mengalami error terkait browser:

    pip install playwright
    

    playwright install chromium

    Hasil Scraping Kosong

    • Periksa apakah URL bisa diakses
    • Coba tambahkan headless: True dan browsertype: chromium di config
    • Pastikan prompt cukup spesifik
    • Periksa apakah website memblokir bot

    Timeout Error

    Tambahkan timeout yang lebih panjang:

    graphconfig = {
    

    "llm": {

    "apikey": "sk-your-api-key",

    "model": "openai/gpt-4o-mini",

    },

    "loader_kwargs": {

    "timeout": 60000,

    },

    }

    Kesimpulan

    ScrapeGraphAI merupakan terobosan dalam dunia web scraping yang menggabungkan kemudahan natural language processing dengan kekuatan graph-based pipeline. Beberapa keunggulan utamanya:

  • Kemudahan Penggunaan: Cukup deskripsikan data yang ingin diekstrak dalam bahasa natural
  • Fleksibilitas: Mendukung berbagai LLM provider dan model lokal
  • Structured Output: Integrasi dengan Pydantic untuk output yang konsisten
  • Skalabilitas: Bisa scraping satu halaman atau banyak halaman sekaligus
  • Adaptabilitas: Tidak bergantung pada CSS selector yang mudah berubah
  • Dengan ScrapeGraphAI, Anda bisa fokus pada data apa yang ingin didapatkan, bukan bagaimana cara mendapatkannya. Library ini sangat cocok untuk data scientist, data engineer, dan developer yang membutuhkan solusi scraping yang cepat dan adaptif.

    Untuk informasi lebih lanjut, kunjungi dokumentasi resmi ScrapeGraphAI di GitHub repository mereka.

    Artikel Terkait

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

    Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng Apa itu Aisuite? Aisuite adalah library Python open...

    Tutorial Lengkap Jupyter AI: Integrasikan LLM Langsung ke Notebook Anda

    Tutorial Lengkap Jupyter AI: Integrasikan LLM Langsung ke Notebook Anda Jupyter Notebook telah menjadi alat utama bagi d...

    Tutorial Lengkap Anthropic Claude API: Dari Dasar hingga Fitur Lanjutan

    Tutorial Lengkap Anthropic Claude API: Dari Dasar hingga Fitur Lanjutan Anthropic Claude adalah salah satu Large Languag...

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom Model bahasa besar (LLM) open-source terus berk...