Tutorial LlamaParse: Parsing Dokumen Kompleks untuk RAG Pipeline

Membangun aplikasi Retrieval-Augmented Generation (RAG) yang akurat sangat bergantung pada kualitas data yang diekstrak dari dokumen sumber. Sayangnya, dokumen dunia nyata seperti PDF, laporan keuangan, paper akademik, dan slide presentasi memiliki struktur yang kompleks — tabel, gambar, header multi-level, dan layout multi-kolom. Tool parsing tradisional sering gagal menangkap struktur ini dengan benar. LlamaParse hadir sebagai solusi parsing dokumen yang didesain khusus untuk menghasilkan output terstruktur berkualitas tinggi yang siap digunakan dalam pipeline RAG.

Dalam tutorial ini, kita akan mempelajari cara menggunakan LlamaParse untuk mengekstrak konten dari berbagai jenis dokumen, mengintegrasikannya dengan LlamaIndex, dan membangun pipeline RAG yang robust.

Apa itu LlamaParse?

LlamaParse adalah layanan parsing dokumen yang dikembangkan oleh tim LlamaIndex. Berbeda dengan parser PDF konvensional yang hanya mengekstrak teks mentah, LlamaParse menggunakan model AI untuk memahami struktur dokumen dan menghasilkan output dalam format Markdown yang terstruktur. Keunggulan utamanya meliputi:

• Parsing tabel dengan akurasi tinggi, termasuk tabel kompleks dengan merged cells
• Ekstraksi konten dari gambar dan diagram menggunakan vision model
• Dukungan untuk lebih dari 10 format file (PDF, DOCX, PPTX, XLSX, HTML, dan lainnya)
• Instruksi parsing kustom untuk mengarahkan proses ekstraksi
• Integrasi langsung dengan ekosistem LlamaIndex

Instalasi dan Setup

Instalasi Package

LlamaParse tersedia sebagai package Python yang bisa diinstal melalui pip:

pip install llama-parse llama-index

Jika Anda hanya membutuhkan parser tanpa framework LlamaIndex lengkap, cukup instal:

pip install llama-parse

Mendapatkan API Key

LlamaParse menggunakan API cloud untuk proses parsing. Anda perlu mendapatkan API key dari LlamaCloud:

Buka cloud.llamaindex.ai

Buat akun atau login

Navigate ke menu API Keys

Generate API key baru

Simpan API key sebagai environment variable:

export LLAMACLOUDAPIKEY="llx-your-api-key-here"

Atau buat file .env di root project:

LLAMACLOUDAPIKEY=llx-your-api-key-here

Verifikasi Instalasi

import llamaparse
print(f"LlamaParse version: {llamaparse.version}")

Basic Usage

Parsing PDF Sederhana

Cara paling dasar menggunakan LlamaParse adalah mem-parse satu file PDF:

from llamaparse import LlamaParse

parser = LlamaParse(
    resulttype="markdown"
)

documents = parser.loaddata("laporankeuangan.pdf")

for doc in documents:
    print(doc.text[:500])

Parameter resulttype menentukan format output. Pilihan yang tersedia:

• "markdown" — output dalam format Markdown (direkomendasikan untuk RAG)
• "text" — output teks biasa tanpa formatting

Parsing Multiple Files

LlamaParse mendukung parsing beberapa file sekaligus:

parser = LlamaParse(resulttype="markdown")

files = [
    "laporanq1.pdf",

    "laporanq2.pdf",
    "presentasibisnis.pptx",

    "datakaryawan.xlsx"
]

alldocuments = []

for filepath in files:
    docs = parser.loaddata(filepath)
    alldocuments.extend(docs)


print(f"Total dokumen yang diparsing: {len(alldocuments)}")

Async Parsing

Untuk performa yang lebih baik saat mem-parse banyak file, gunakan async API:

import asyncio
from llamaparse import LlamaParse


async def parsedocuments():
    parser = LlamaParse(resulttype="markdown")


    files = [
        "dokumen1.pdf",
        "dokumen2.pdf",

        "dokumen3.pdf",
    ]

    tasks = [parser.aloaddata(f) for f in files]

    results = await asyncio.gather(*tasks)

    alldocs = []
    for docs in results:
        alldocs.extend(docs)


    return alldocs

documents = asyncio.run(parsedocuments())

print(f"Total halaman: {len(documents)}")

Advanced Usage

Custom Parsing Instructions

Salah satu fitur paling berguna dari LlamaParse adalah kemampuan memberikan instruksi kustom untuk mengarahkan proses parsing. Ini sangat berguna ketika Anda memiliki dokumen dengan format spesifik:

parser = LlamaParse(
    resulttype="markdown",
    parsinginstruction="""

    Dokumen ini adalah laporan keuangan perusahaan.
    Pastikan untuk:
Mengekstrak semua tabel keuangan dengan format yang benar
Mempertahankan hierarki heading (judul bab, sub-bab)
Mengabaikan header dan footer halaman
Mengekstrak catatan kaki sebagai bagian terpisah
Format angka keuangan dengan pemisah ribuan
    """
)

documents = parser.loaddata("annualreport.pdf")

Parsing Tabel Kompleks

LlamaParse memiliki kemampuan khusus untuk menangani tabel yang rumit:

parser = LlamaParse(
    resulttype="markdown",
    parsinginstruction="""

    Fokus pada ekstraksi tabel yang akurat.
    Pertahankan semua kolom dan baris, termasuk merged cells.
    Gunakan format Markdown table yang standard.
    Jika ada tabel yang span multiple pages, gabungkan menjadi satu tabel.
    """
)

documents = parser.loaddata("datastatistik.pdf")


for doc in documents:
    lines = doc.text.split('\n')
    tablelines = [l for l in lines if '|' in l]
    if tablelines:

        print("Tabel ditemukan:")
        for line in tablelines[:10]:
            print(line)

Multimodal Parsing dengan Gambar

LlamaParse dapat mengekstrak informasi dari gambar dan diagram dalam dokumen:

parser = LlamaParse(
    resulttype="markdown",

    usevendormultimodalmodel=True,
    vendormultimodalmodelname="openai-gpt4o",

    parsinginstruction="""
    Untuk setiap gambar atau diagram dalam dokumen:
Deskripsikan konten visual secara detail
Ekstrak teks yang ada dalam gambar
Jika ada chart/grafik, jelaskan data yang ditampilkan
    """
)

documents = parser.loaddata("presentasidengangrafik.pdf")

Pengaturan Bahasa

Untuk dokumen berbahasa Indonesia atau bahasa lain selain Inggris:

parser = LlamaParse(
    resulttype="markdown",
    language="id",
    parsinginstruction="""

    Dokumen ini dalam Bahasa Indonesia.
    Pertahankan bahasa asli dokumen.
    Jangan menerjemahkan konten ke bahasa lain.
    """
)

documents = parser.loaddata("dokumenindonesia.pdf")

Konfigurasi Lanjutan

LlamaParse menyediakan berbagai parameter untuk fine-tuning proses parsing:

parser = LlamaParse(
    resulttype="markdown",
    numworkers=4,

    verbose=True,
    showprogress=True,
    splitbypage=True,
    skipdiagonaltext=True,
    donotunrollcolumns=False,

    pageseparator="\n\n---PAGE BREAK---\n\n",
)

documents = parser.loaddata("dokumenpanjang.pdf")

for i, doc in enumerate(documents):
    print(f"Halaman {i+1}: {len(doc.text)} karakter")

Parameter penting yang perlu diketahui:

• numworkers: Jumlah worker paralel untuk parsing (default: 4)
• splitbypage: Pisahkan output per halaman (berguna untuk chunking)
• skipdiagonaltext: Abaikan teks diagonal (watermark)
• pageseparator: String pemisah antar halaman

Integrasi dengan LlamaIndex untuk RAG

Pipeline RAG Dasar

Berikut cara membangun pipeline RAG lengkap menggunakan LlamaParse dan LlamaIndex:

from llamaparse import LlamaParse
from llamaindex.core import VectorStoreIndex, Settings
from llamaindex.core.nodeparser import MarkdownNodeParser
from llamaindex.llms.openai import OpenAI

from llamaindex.embeddings.openai import OpenAIEmbedding

Settings.llm = OpenAI(model="gpt-4o-mini")
Settings.embedmodel = OpenAIEmbedding(model="text-embedding-3-small")


parser = LlamaParse(
    resulttype="markdown",
    parsinginstruction="Ekstrak konten dengan struktur heading yang jelas."

)

documents = parser.loaddata("knowledgebase.pdf")


nodeparser = MarkdownNodeParser()
nodes = nodeparser.getnodesfromdocuments(documents)

index = VectorStoreIndex(nodes)

queryengine = index.asqueryengine(

    similaritytopk=5

)

response = queryengine.query("Apa kesimpulan utama dari laporan ini?")
print(response)

Menggunakan MarkdownNodeParser

Karena LlamaParse menghasilkan output Markdown, MarkdownNodeParser adalah pilihan terbaik untuk chunking:

from llamaindex.core.nodeparser import MarkdownNodeParser

nodeparser = MarkdownNodeParser()


nodes = nodeparser.getnodesfromdocuments(documents)


for node in nodes[:5]:
    print(f"Node ID: {node.nodeid}")
    print(f"Metadata: {node.metadata}")
    print(f"Content preview: {node.text[:200]}")
    print("---")

MarkdownNodeParser secara otomatis memecah dokumen berdasarkan heading Markdown, sehingga setiap chunk memiliki konteks yang koheren.

Pipeline RAG dengan Metadata Filtering

Untuk koleksi dokumen yang besar, metadata filtering membantu meningkatkan akurasi retrieval:

from llamaparse import LlamaParse
from llamaindex.core import VectorStoreIndex, Document
from llamaindex.core.nodeparser import MarkdownNodeParser

parser = LlamaParse(resulttype="markdown")


fileconfigs = [
    {"path": "laporan2024.pdf", "category": "keuangan", "year": "2024"},

    {"path": "laporan2025.pdf", "category": "keuangan", "year": "2025"},
    {"path": "kebijakanhr.pdf", "category": "hr", "year": "2025"},

]

allnodes = []
nodeparser = MarkdownNodeParser()


for config in fileconfigs:
    docs = parser.loaddata(config["path"])

    for doc in docs:
        doc.metadata.update({
            "category": config["category"],
            "year": config["year"],
            "source": config["path"]
        })
    nodes = nodeparser.getnodesfromdocuments(docs)

    allnodes.extend(nodes)

index = VectorStoreIndex(allnodes)


from llamaindex.core.vectorstores import MetadataFilter, FilterOperator


queryengine = index.asqueryengine(
    similaritytopk=5,
    filters=[
        MetadataFilter(key="category", value="keuangan"),
        MetadataFilter(key="year", value="2025"),
    ]
)

response = queryengine.query("Berapa total revenue tahun 2025?")

print(response)

Chat Engine dengan Konteks Dokumen

Untuk membangun chatbot yang bisa menjawab pertanyaan berdasarkan dokumen:

from llamaparse import LlamaParse
from llamaindex.core import VectorStoreIndex

from llamaindex.core.nodeparser import MarkdownNodeParser

from llamaindex.core.memory import ChatMemoryBuffer

parser = LlamaParse(resulttype="markdown")

documents = parser.loaddata("manualproduk.pdf")


nodeparser = MarkdownNodeParser()
nodes = nodeparser.getnodesfromdocuments(documents)

index = VectorStoreIndex(nodes)

memory = ChatMemoryBuffer.fromdefaults(tokenlimit=3000)
chatengine = index.aschatengine(

    chatmode="condensepluscontext",
    memory=memory,
    systemprompt="""

    Kamu adalah asisten yang membantu menjawab pertanyaan
    berdasarkan dokumen manual produk. Jawab dalam Bahasa Indonesia.
    Jika informasi tidak ada di dokumen, katakan dengan jujur.
    """
)

response = chatengine.chat("Bagaimana cara menginstal produk ini?")
print(response)

response = chatengine.chat("Apa saja persyaratan sistemnya?")

print(response)

Penanganan Format File Khusus

Parsing Spreadsheet (XLSX/CSV)

parser = LlamaParse(
    resulttype="markdown",
    parsinginstruction="""

    Ini adalah file spreadsheet. Konversi setiap sheet menjadi tabel Markdown.
    Pertahankan nama sheet sebagai heading.
    Format angka sesuai konteks (mata uang, persentase, dll).
    """
)

documents = parser.loaddata("datapenjualan.xlsx")

print(documents[0].text)

Parsing PowerPoint (PPTX)

parser = LlamaParse(
    resulttype="markdown",
    usevendormultimodalmodel=True,

    vendormultimodalmodelname="openai-gpt4o",
    parsinginstruction="""

    Ini adalah presentasi PowerPoint. Untuk setiap slide:
Gunakan judul slide sebagai heading
Ekstrak semua bullet points
Deskripsikan gambar dan diagram yang ada
Pertahankan urutan slide
    """
)

documents = parser.loaddata("presentasiquarterly.pptx")

Parsing Dokumen Word (DOCX)

parser = LlamaParse(
    resulttype="markdown",
    parsinginstruction="""

    Pertahankan struktur heading dokumen Word.
    Konversi tabel ke format Markdown.
    Pertahankan formatting bold dan italic.
    """
)

documents = parser.loaddata("proposalproyek.docx")

Best Practices

1. Pilih Parsing Instruction yang Tepat

Parsing instruction adalah kunci untuk mendapatkan output berkualitas tinggi. Beberapa tips:

# Untuk laporan keuangan
financialinstruction = """
Dokumen ini adalah laporan keuangan. Prioritaskan:
Akurasi angka dan format mata uang
Struktur tabel neraca dan laba rugi
Catatan atas laporan keuangan
"""


Untuk paper akademik
academicinstruction = """

Dokumen ini adalah paper akademik. Prioritaskan:
Struktur sections (Abstract, Introduction, Methods, Results, Discussion)
Formula matematika (gunakan LaTeX notation)
Referensi dan sitasi
Caption tabel dan gambar
"""


Untuk dokumen legal
legalinstruction = """
Dokumen ini adalah dokumen hukum. Prioritaskan:
Penomoran pasal dan ayat
Definisi istilah
Klausul dan sub-klausul
Pertahankan format penomoran asli
"""

2. Optimasi Chunking Strategy

Pilih strategi chunking yang sesuai dengan jenis dokumen:

from llamaindex.core.nodeparser import (
    MarkdownNodeParser,
    SentenceSplitter,
)

Untuk dokumen dengan heading yang jelas
markdownparser = MarkdownNodeParser()


Untuk dokumen tanpa struktur heading yang konsisten
sentenceparser = SentenceSplitter(
    chunksize=1024,

    chunkoverlap=200
)

Gunakan berdasarkan jenis dokumen
nodes = markdownparser.getnodesfromdocuments(documents)

3. Error Handling yang Robust

from llamaparse import LlamaParse
import os

def safeparse(filepath, maxretries=3):
    if not os.path.exists(filepath):

        raise FileNotFoundError(f"File tidak ditemukan: {filepath}")

    parser = LlamaParse(
        resulttype="markdown",

        verbose=True
    )

    for attempt in range(maxretries):
        try:
            documents = parser.loaddata(filepath)
            if not documents:
                print(f"Warning: Tidak ada konten dari {filepath}")

                return []
            return documents
        except Exception as e:
            print(f"Attempt {attempt + 1}/{maxretries} gagal: {e}")
            if attempt == maxretries - 1:

                raise

    return []

try:
    docs = safeparse("laporan.pdf")
    print(f"Berhasil parsing {len(docs)} dokumen")
except Exception as e:
    print(f"Gagal parsing: {e}")

4. Caching Hasil Parsing

Untuk menghindari parsing ulang dokumen yang sama:

import json
import hashlib
import os
from llamaparse import LlamaParse


CACHEDIR = ".parsecache"


def getfilehash(filepath):
    with open(filepath, "rb") as f:

        return hashlib.md5(f.read()).hexdigest()

def parsewithcache(filepath):
    os.makedirs(CACHEDIR, existok=True)

    filehash = getfilehash(filepath)
    cachepath = os.path.join(CACHEDIR, f"{filehash}.json")


    if os.path.exists(cachepath):
        print(f"Menggunakan cache untuk {filepath}")

        with open(cachepath, "r") as f:
            cached = json.load(f)
        from llamaindex.core import Document

        return [Document(text=d["text"], metadata=d["metadata"]) for d in cached]

    parser = LlamaParse(resulttype="markdown")
    documents = parser.loaddata(filepath)

    cachedata = [{"text": d.text, "metadata": d.metadata} for d in documents]

    with open(cachepath, "w") as f:
        json.dump(cachedata, f)


    print(f"Hasil parsing di-cache ke {cachepath}")
    return documents

5. Monitoring Penggunaan API

LlamaParse memiliki tier gratis dengan batasan jumlah halaman per hari. Pantau penggunaan Anda:

def parsewithpagecount(filepath, dailylimit=1000):
    parser = LlamaParse(
        resulttype="markdown",
        splitbypage=True,
        verbose=True
    )

    documents = parser.loaddata(filepath)
    pagecount = len(documents)


    print(f"File: {filepath}")
    print(f"Halaman yang diproses: {pagecount}")

    print(f"Estimasi sisa kuota harian: {dailylimit - pagecount}")


    return documents

Perbandingan dengan Tool Parsing Lain

| Fitur | LlamaParse | PyPDF2 | Unstructured | Docling |

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

| Akurasi tabel | Tinggi | Rendah | Sedang | Tinggi |

| Multimodal | Ya | Tidak | Terbatas | Ya |

| Format output | Markdown/Text | Text | JSON/Text | Markdown/JSON |

| Custom instructions | Ya | Tidak | Tidak | Terbatas |

| Harga | Freemium | Gratis | Freemium | Gratis |

| Self-hosted | Tidak | Ya | Ya | Ya |

| Kecepatan | Sedang | Cepat | Sedang | Sedang |

Kesimpulan

LlamaParse adalah tool yang sangat berguna untuk membangun pipeline RAG yang membutuhkan ekstraksi dokumen berkualitas tinggi. Keunggulan utamanya terletak pada kemampuan menangani tabel kompleks, dukungan multimodal, dan integrasi yang mulus dengan ekosistem LlamaIndex.

Beberapa poin penting yang perlu diingat:

• Gunakan resulttype="markdown" untuk output terbaik dalam pipeline RAG
• Manfaatkan parsing instruction untuk mengarahkan proses ekstraksi sesuai jenis dokumen
• Gunakan MarkdownNodeParser untuk chunking yang optimal
• Implementasikan caching untuk menghemat kuota API
• Pertimbangkan async parsing untuk batch processing dokumen dalam jumlah besar

Dengan menggabungkan LlamaParse dan LlamaIndex, Anda dapat membangun aplikasi RAG yang mampu menjawab pertanyaan secara akurat berdasarkan dokumen bisnis yang kompleks — mulai dari laporan keuangan hingga dokumen teknis.