LlamaIndex 文档加载器：PDF网页解析处理完全指南

ในโลกของ RAG (Retrieval-Augmented Generation) การโหลดเอกสารที่ถูกต้องคือหัวใจสำคัญ ผมได้ทดสอบ LlamaIndex กับโปรเจกต์จริงหลายตัว พบว่าการ parse PDF และ web page มีเทคนิคที่หลายคนมองข้าม บทความนี้จะสอนทุกอย่างตั้งแต่พื้นฐานจนถึง advanced optimization

ต้นทุน API 2026 — เปรียบเทียบก่อนตัดสินใจ

ก่อนจะเข้าสู่เนื้อหาหลัก มาดูต้นทุนที่แม่นยำที่สุดในปี 2026 กัน

โมเดล	Output ($/MTok)	10M tokens/เดือน ($)
GPT-4.1	$8.00	$80
Claude Sonnet 4.5	$15.00	$150
Gemini 2.5 Flash	$2.50	$25
DeepSeek V3.2	$0.42	$4.20

จะเห็นได้ว่า DeepSeek V3.2 ถูกกว่า GPT-4.1 ถึง 19 เท่า สำหรับงาน indexing ทั่วไป ผมแนะนำใช้ DeepSeek เป็นหลักแล้วสลับไป Claude สำหรับงาน quality-critical

สมัครที่นี่ เพื่อรับเครดิตฟรีและทดลองใช้ HolySheep AI — ผู้ให้บริการ AI API ที่รองรับทุกโมเดลข้างต้นในราคาพิเศษ อัตราแลกเปลี่ยน ¥1=$1 ประหยัดได้มากกว่า 85% รองรับ WeChat และ Alipay พร้อม latency ต่ำกว่า 50ms

ทำไมต้อง LlamaIndex Document Loader

LlamaIndex เป็น framework ที่ทรงพลังที่สุดสำหรับงาน document ingestion ในปี 2026 ผมใช้งานจริงกับลูกค้าหลายราย พบว่ามันช่วยลดเวลา development ลงได้ถึง 70% เมื่อเทียบกับการเขียน parser เอง

การติดตั้งและ Setup

# ติดตั้ง dependencies ที่จำเป็น
pip install llama-index llama-index-readers-file 
pip install llama-index-readers-web pypdf python-dotenv

สำหรับ PDF ที่มีภาพ (OCR)
pip install pymupdf pillow

ติดตั้ง OpenCV สำหรับ image processing
pip install opencv-python-headless

PDF Loading — หลายวิธีที่ต้องรู้

1. Simple PDF Loader

from llama_index.core import SimpleDirectoryReader
from llama_index.readers.file import PDFReader

วิธีที่ง่ายที่สุด — ใช้ได้เลย
documents = SimpleDirectoryReader(
    input_files=["/path/to/document.pdf"]
).load_data()

print(f"โหลดสำเร็จ: {len(documents)} pages")

ดู content ที่ parse ได้
for i, doc in enumerate(documents[:3]):
    print(f"\n--- Page {i+1} ---")
    print(doc.text[:500] + "...")

2. PDF Loader with Metadata Extraction

from llama_index.readers.file import PDFReader
from llama_index.core import Document

def load_pdf_with_metadata(file_path: str, filename: str) -> list[Document]:
    """โหลด PDF และ extract metadata ที่เป็นประโยชน์"""
    
    loader = PDFReader()
    
    # extract_images=True สำหรับ PDF ที่มีรูปภาพ
    documents = loader.load_data(file_path=file_path)
    
    # เพิ่ม metadata ที่ custom
    for doc in documents:
        doc.metadata = {
            "file_name": filename,
            "file_type": "application/pdf",
            "page_num": doc.metadata.get("page_label", 0),
            "source": "customer_document"
        }
    
    return documents

ใช้งาน
docs = load_pdf_with_metadata(
    "/data/invoice_2024.pdf", 
    "invoice_2024.pdf"
)

Web Page Loading — Crawler และ Parser

Simple Web Page Loader

from llama_index.readers.web import SimpleWebPageReader

วิธีง่ายที่สุดสำหรับ web scraping
loader = SimpleWebPageReader()

documents = loader.load_data(
    urls=["https://example.com/article"]
)

ดูผลลัพธ์
print(documents[0].text)

Web Page Loader with HTML Extraction

from llama_index.readers.web import GenericWebLoader
from llama_index.core import Document

class WebPageProcessor:
    """Processor สำหรับ web pages ที่ซับซ้อน"""
    
    def __init__(self, html_to_text: bool = True):
        self.html_to_text = html_to_text
    
    def load_with_config(self, url: str, config: dict = None) -> Document:
        """Load web page พร้อม config สำหรับ parsing"""
        
        loader = GenericWebLoader(
            url=url,
            # กำหนด CSS selectors ที่ต้องการ
            css_selector=config.get("css_selector", "main, article") 
            if config else "main, article"
        )
        
        docs = loader.load()
        
        if not docs:
            raise ValueError(f"ไม่สามารถโหลด {url}")
        
        doc = docs[0]
        doc.metadata = {
            "source_url": url,
            "title": doc.metadata.get("title", ""),
            "language": "th",  # สำหรับเว็บไทย
            "crawled_at": "2026-01-15"
        }
        
        return doc

ใช้งาน
processor = WebPageProcessor()
doc = processor.load_with_config(
    "https://thainews.example.com/tech/article",
    {"css_selector": "article.content"}
)

Combining Documents — รวมหลาย Source

ในโปรเจกต์จริง คุณต้องรวม PDF หลายตัวกับ web pages หลายเว็บเข้าด้วยกัน LlamaIndex ทำได้ง่ายมาก

from llama_index.core import SimpleDirectoryReader
from llama_index.readers.web import SimpleWebPageReader
from llama_index.core import VectorStoreIndex

class MultiSourceDocumentLoader:
    """รวมเอกสารจากหลายแหล่ง"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.pdf_reader = SimpleDirectoryReader
        self.web_reader = SimpleWebPageReader()
    
    def load_all(self, config: dict) -> list[Document]:
        all_docs = []
        
        # 1. โหลด PDFs
        if "pdf_dir" in config:
            pdf_docs = SimpleDirectoryReader(
                input_dir=config["pdf_dir"],
                file_extractor={".pdf": "PDFReader"}
            ).load_data()
            all_docs.extend(pdf_docs)
            print(f"โหลด PDF: {len(pdf_docs)} documents")
        
        # 2. โหลด Web Pages
        if "urls" in config:
            web_docs = self.web_reader.load_data(urls=config["urls"])
            all_docs.extend(web_docs)
            print(f"โหลด Web: {len(web_docs)} documents")
        
        # 3. โหลดไฟล์อื่นๆ (txt, md, docx)
        if "other_dir" in config:
            other_docs = SimpleDirectoryReader(
                input_dir=config["other_dir"]
            ).load_data()
            all_docs.extend(other_docs)
        
        print(f"รวมทั้งหมด: {len(all_docs)} documents")
        return all_docs

ใช้งาน
loader = MultiSourceDocumentLoader(api_key="YOUR_HOLYSHEEP_API_KEY")

config = {
    "pdf_dir": "/data/pdfs/",
    "urls": [
        "https://docs.example.com/api-guide",
        "https://blog.example.com/tutorial"
    ],
    "other_dir": "/data/texts/"
}

documents = loader.load_all(config)

Advanced: Parsing Strategy ตามประเภทเอกสาร

จากประสบการณ์ ผมพบว่าการ parse แบบ one-size-fits-all ไม่ได้ผลดีเสมอไป แต่ละประเภทเอกสารต้องใช้ strategy ต่างกัน

Table Extraction สำหรับ PDF ที่มีตาราง

from llama_index.readers.file import PDFReader
from llama_index.core.schema import TableNode

def extract_tables_from_pdf(pdf_path: str) -> list[TableNode]:
    """Extract tables ออกมาจาก PDF อย่างถูกต้อง"""
    
    loader = PDFReader()
    documents = loader.load_data(file_path=pdf_path)
    
    tables = []
    
    for doc in documents:
        # PDF Reader จะ auto-detect tables
        if doc.metadata.get("table"):
            table_node = TableNode(
                text=doc.metadata["table"],
                table=doc.metadata["table"],
                metadata={"source": pdf_path}
            )
            tables.append(table_node)
    
    return tables

ใช้กับ invoice หรือ financial documents
invoice_tables = extract_tables_from_pdf("/data/invoice.pdf")

Integration กับ HolySheep API

หลังจาก parse เอกสารเสร็จแล้ว ขั้นตอนต่อไปคือส่งไปยัง LLM เพื่อทำ indexing ด้วย HolySheep คุณสามารถใช้โมเดลได้หลายตัวตามความเหมาะสม

from openai import OpenAI

Initialize HolySheep Client
client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"  # บังคับใช้ HolySheep endpoint
)

def index_documents_with_embedding(documents: list, model: str = "deepseek"):
    """สร้าง embeddings สำหรับ documents ทั้งหมด"""
    
    # เลือก model ตาม use case
    embedding_model = {
        "deepseek": "deepseek/deepseek-chat-v3",
        "gpt": "openai/gpt-4.1",
        "claude": "anthropic/claude-sonnet-4.5"
    }.get(model, "deepseek/deepseek-chat-v3")
    
    texts = [doc.text for doc in documents]
    
    # สร้าง embeddings
    response = client.embeddings.create(
        model=embedding_model,
        input=texts
    )
    
    embeddings = [item.embedding for item in response.data]
    
    # ส่งกลับพร้อม documents
    return [
        {**doc.__dict__, "embedding": emb} 
        for doc, emb in zip(documents, embeddings)
    ]

ใช้งาน
indexed_docs = index_documents_with_embedding(documents, model="deepseek")

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

ปัญหาที่ 1: PDF ภาษาไทยอ่านไม่ออก

# ❌ วิธีที่ผิด - PDF ไทยมักมีปัญหากับ PyPDF2
from llama_index.readers.file import PDFReader

loader = PDFReader()  # ใช้ PyPDF2 ซึ่งรองรับภาษาไทยไม่ดี

✅ วิธีที่ถูกต้อง - ใช้ PyMuPDF
from llama_index.readers.file import PyMuPDFReader

loader = PyMuPDFReader()

เพิ่ม language hint สำหรับ OCR
documents = loader.load_data(
    file_path="/data/thai_document.pdf",
    metadata_extractor={
        "language": "thai"
    }
)

หรือถ้า still ไม่ได้ ใช้ OCR
import pytesseract
from PIL import Image

def ocr_thai_pdf(pdf_path: str) -> list[str]:
    """OCR สำหรับ PDF ภาษาไทยโดยเฉพาะ"""
    import fitz  # PyMuPDF
    
    doc = fitz.open(pdf_path)
    pages_text = []
    
    for page in doc:
        # Render เป็น image
        pix = page.get_pixmap(dpi=300)
        img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
        
        # OCR ด้วย Tesseract
        text = pytesseract.image_to_string(
            img, 
            lang='tha+eng',  # Thai + English
            config='--psm 4'  # Assume uniform block of text
        )
        pages_text.append(text)
    
    return pages_text

ปัญหาที่ 2: Web Loader ดึง HTML แทนเนื้อหา

# ❌ วิธีที่ผิด - ได้ HTML source code
from llama_index.readers.web import SimpleWebPageReader

loader = SimpleWebPageReader()
docs = loader.load_data(urls=["https://example.com"])
print(docs[0].text)  # จะได้ HTML แทนที่จะเป็น text

✅ วิธีที่ถูกต้อง - ใช้ BeautifulSoupWebReader
from llama_index.readers.web import BeautifulSoupWebReader

loader = BeautifulSoupWebReader(
    html_to_text=True  # บังคับ convert เป็น text
)

ระบุ CSS selectors ที่ต้องการ
docs = loader.load_data(
    urls=["https://thainews.example.com/article"],
    css_mapping={
        "text": "article.content, div.post-body, main"
    }
)

ตรวจสอบผลลัพธ์
clean_text = docs[0].text
print(f"Clean text length: {len(clean_text)}")

ปัญหาที่ 3: Memory Error กับไฟล์ใหญ่

# ❌ วิธีที่ผิด - โหลดทั้งไฟล์เข้า memory
documents = SimpleDirectoryReader(
    input_files=["/data/huge_document.pdf"]
).load_data()

✅ วิธีที่ถูกต้อง - ใช้ chunking และ streaming
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core import Document

def load_large_pdf_chunked(pdf_path: str, chunk_size: int = 1024) -> list[Document]:
    """โหลด PDF ใหญ่เป็น chunks เพื่อประหยัด memory"""
    
    from llama_index.readers.file import PDFReader
    
    loader = PDFReader()
    
    # โหลดแบบ streaming - ทีละ page
    documents = loader.load_data(file_path=pdf_path)
    
    # Parse แต่ละ document
    node_parser = SentenceSplitter(
        chunk_size=chunk_size,
        chunk_overlap=100
    )
    
    all_nodes = []
    for doc in documents:
        nodes = node_parser.get_nodes_from_documents([doc])
        all_nodes.extend(nodes)
    
    print(f"แบ่งเป็น {len(all_nodes)} chunks")
    return all_nodes

หรือใช้ async loading
import asyncio

async def load_multiple_pdfs_async(file_paths: list[str]) -> list[Document]:
    """โหลด PDFs หลายตัวแบบ async"""
    
    async def load_single(path: str) -> list[Document]:
        loader = PDFReader()
        return loader.load_data(file_path=path)
    
    # ทำ concurrently แต่จำกัด memory
    semaphore = asyncio.Semaphore(2)  # Max 2 files at a time
    
    async def load_with_limit(path: str):
        async with semaphore:
            return await load_single(path)
    
    tasks = [load_with_limit(p) for p in file_paths]
    results = await asyncio.gather(*tasks)
    
    return [doc for result in results for doc in result]

ปัญหาที่ 4: Rate Limit เมื่อใช้ API

# ❌ วิธีที่ผิด - เรียก API พร้อมกันเยอะเกิน
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"
)

ส่ง 100 requests พร้อมกัน
for doc in documents:
    response = client.embeddings.create(
        model="deepseek/deepseek-chat-v3",
        input=doc.text
    )

✅ วิธีที่ถูกต้อง - ใช้ rate limiting
import time
from ratelimit import limits, sleep_and_retry

@sleep_and_retry
@limits(calls=60, period=60)  # Max 60 calls per minute
def create_embedding_with_limit(client, text: str):
    """สร้าง embedding พร้อม rate limit protection"""
    return client.embeddings.create(
        model="deepseek/deepseek-chat-v3",
        input=text
    )

ใช้ batching เพื่อลดจำนวน API calls
def create_embeddings_batched(client, texts: list[str], batch_size: int = 100):
    """สร้าง embeddings แบบ batched"""
    
    all_embeddings = []
    
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        
        response = client.embeddings.create(
            model="deepseek/deepseek-chat-v3",
            input=batch
        )
        
        embeddings = [item.embedding for item in response.data]
        all_embeddings.extend(embeddings)
        
        print(f"Processed batch {i//batch_size + 1}: {len(batch)} texts")
        
        # Delay เล็กน้อยระหว่าง batches
        time.sleep(0.5)
    
    return all_embeddings

สรุป

การใช้ LlamaIndex สำหรับ document loading ไม่ใช่เรื่องยาก แต่ต้องเข้าใจ best practices ของแต่ละประเภทเอกสาร บทความนี้ครอบคลุม PDF loading, web page parsing, multi-source combination และการแก้ปัญหาที่พบบ่อย 4 กรณีที่ผมเจอจริงในการทำงาน

สำหรับต้นทุน อย่าลืมว่า DeepSeek V3.2 ที่ $0.42/MTok สามารถประหยัดได้ถึง 95% เมื่อเทียบกับ Claude Sonnet 4.5 สำหรับงาน indexing ทั่วไป คุ้มค่ามากที่จะลองใช้ HolySheep AI ที่รองรับทุกโมเดลในราคาพิเศษ

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน