LlamaIndex 节点分割：文档分块的优化策略

การสร้างระบบ RAG (Retrieval-Augmented Generation) ที่มีประสิทธิภาพสูงไม่ได้ขึ้นอยู่กับการเลือก LLM ที่ดีที่สุดเพียงอย่างเดียว แต่ยังรวมถึงการตัดแบ่งเอกสารอย่างชาญฉลาดด้วย ในบทความนี้ผมจะแบ่งปันประสบการณ์ตรงจากการ implement ระบบ RAG สำหรับลูกค้าอีคอมเมิร์ซรายใหญ่และองค์กรธุรกิจ พร้อมโค้ดตัวอย่างที่พร้อมใช้งานจริง

ทำไม Node Splitting ถึงสำคัญสำหรับ RAG

ในโปรเจกต์ล่าสุดที่ผมทำ ลูกค้ารายหนึ่งใช้งานแชทบอท AI สำหรับบริการลูกค้าอีคอมเมิร์ซ แต่พบว่าคำตอบมักจะไม่ตรงประเด็น เมื่อตรวจสอบพบว่าปัญหาอยู่ที่การ chunk เอกสารคำถามที่ถูกถามบ่อย เช่น "นโยบายการคืนสินค้า" ถูกตัดแบ่งรวมกับเนื้อหาอื่นทำให้ retrieval ดึงข้อมูลมาไม่ครบถ้วน

การแบ่ง node ที่ดีจะช่วยให้:

• Context window ใช้งานได้คุ้มค่าขึ้น — ดึงเฉพาะส่วนที่เกี่ยวข้องจริงๆ
• ความแม่นยำในการตอบคำถามเพิ่มขึ้น 30-50%
• ลด hallucination เพราะ LLM ได้ context ที่ถูกต้อง
• ประหยัด cost เพราะส่ง token น้อยลง

กลยุทธ์ Node Splitting พื้นฐาน

1. Sentence Splitter — เหมาะกับเนื้อหาสั้น

# Basic Sentence-based Node Parser
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core import Document

กรณีใช้งาน: FAQ, คำถามที่พบบ่อย, นโยบายสั้นๆ
node_parser = SentenceSplitter(
    chunk_size=512,        # จำนวนอักขระต่อ node
    chunk_overlap=50,       # overlap เพื่อไม่ให้ขาด context
    separator="\n"
)

ตัวอย่างการใช้งานกับ HolySheep API
from openai import OpenAI

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

สร้าง documents จาก FAQ สินค้า
documents = [
    Document(text="นโยบายการคืนสินค้า: สามารถคืนได้ภายใน 7 วัน..."),
    Document(text="วิธีการสั่งซื้อ: เลือกสินค้า ใส่ตะกร้า ชำระเงิน..."),
]

nodes = node_parser.get_nodes_from_documents(documents)
print(f"สร้างได้ {len(nodes)} nodes")

2. Token Splitter — เหมาะกับ LLM Context Window

# Token-based Node Parser เหมาะกับ model ที่มี context เฉพาะ
from llama_index.core.node_parser import TokenTextSplitter
from llama_index.core import SimpleDirectoryReader

กรณีใช้งาน: เอกสารยาว, คู่มือผลิตภัณฑ์
node_parser = TokenTextSplitter(
    chunk_size=1024,         # หน่วย token (แนะนำตาม model)
    chunk_overlap=128,      # overlap 15% ของ chunk_size
    separator=" ",
)

โหลดเอกสารจากโฟลเดอร์
reader = SimpleDirectoryReader(input_dir="./docs")
documents = reader.load_data()

แบ่ง nodes
nodes = node_parser.get_nodes_from_documents(documents)

สร้าง VectorStoreIndex พร้อมใช้งาน
from llama_index.core import VectorStoreIndex

index = VectorStoreIndex(nodes)

สร้าง query engine พร้อม reranking
query_engine = index.as_query_engine(
    similarity_top_k=5,
    verbose=True
)

ทดสอบ query
response = query_engine.query("นโยบายการคืนสินค้ามีระยะเวลาเท่าไหร่?")
print(response)

กลยุทธ์ขั้นสูง: Hierarchical Node Parsing

สำหรับโปรเจกต์ที่ผมทำให้องค์กรธุรกิจขนาดใหญ่ การใช้ hierarchical approach ช่วยเพิ่มความแม่นยำได้มาก โดยจะแบ่งเอกสารเป็น parent nodes และ child nodes

# Hierarchical Node Parser — Parent-Child Relationship
from llama_index.core.node_parser import HierarchicalNodeParser
from llama_index.core.node_parser import get_leaf_nodes, get_deeper_nodes

กรณีใช้งาน: เอกสารองค์กรขนาดใหญ่, คู่มือการใช้งาน
hierarchical_parser = HierarchicalNodeParser(
    chunk_sizes=[2048, 512, 128],  # Parent → Middle → Leaf
    chunk_overlap=100
)

documents = [
    Document(text="""คู่มือการใช้งานระบบ ERP
    บทที่ 1: การเริ่มต้นใช้งาน
    1.1 การเข้าสู่ระบบ
    - เปิดเบราว์เซอร์ไปที่erp.company.com
    - กรอก username และ password
    - กดปุ่ม Login
    1.2 การตั้งค่าโปรไฟล์
    - ไปที่ Settings → Profile
    - แก้ไขข้อมูลส่วนตัว
    - กด Save"""
    )
]

nodes = hierarchical_parser.get_nodes_from_documents(documents)

แยกประเภท node
leaf_nodes = get_leaf_nodes(nodes)
parent_nodes = get_deeper_nodes(nodes)

print(f"Parent nodes: {len(parent_nodes)}")
print(f"Leaf nodes: {len(leaf_nodes)}")

สร้าง Summary Index สำหรับ parent context
from llama_index.core import SummaryIndex

summary_index = SummaryIndex(parent_nodes)

Query ด้วย parent retrieval
summary_query = summary_index.as_query_engine(response_mode="tree_summarize")
context = summary_query.query("สรุปเนื้อหาคู่มือนี้")

Metadata Extraction สำหรับ Smart Retrieval

# เพิ่ม metadata เพื่อช่วย filtering และ retrieval
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core.extractors import (
    SummaryExtractor,
    KeywordExtractor,
    EntityExtractor,
)
from llama_index.core import Document

กำหนด extractors หลายตัว
extractors = [
    SummaryExtractor(llm=client),      # สร้าง summary อัตโนมัติ
    KeywordExtractor(keywords=10),      # ดึง keywords หลัก
    EntityExtractor(prediction_threshold=0.5),  # ดึง entity names
]

node_parser = SentenceSplitter(
    chunk_size=512,
    extractors=extractors
)

documents = [
    Document(
        text="สินค้าคุณภาพสูง ราคาประหยัด จัดส่งฟรี",
        metadata={
            "product_id": "SKU-001",
            "category": "อิเล็กทรอนิกส์",
            "price": 2990
        }
    )
]

nodes = node_parser.get_nodes_from_documents(documents)

ตรวจสอบ metadata ที่ถูกเพิ่ม
for node in nodes:
    print(f"Summary: {node.metadata.get('summary', 'N/A')}")
    print(f"Keywords: {node.metadata.get('keywords', 'N/A')}")

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

กรณีที่ 1: Chunk Size ใหญ่เกินไปทำให้ Context เพี้ยน

อาการ: LLM ตอบคำถามผิดเพราะดึงข้อมูลมาหลายส่วนที่ไม่เกี่ยวข้อง ทำให้ context สับสน

# ❌ วิธีผิด: chunk_size ใหญ่เกินไป
node_parser = SentenceSplitter(chunk_size=4096)

✅ วิธีถูก: ปรับ chunk_size ให้เหมาะกับเนื้อหา
node_parser = SentenceSplitter(
    chunk_size=512,        # เหมาะกับคำถามเฉพาะเจาะจง
    chunk_overlap=64,      # เพิ่ม overlap เพื่อรักษา continuity
)

หรือใช้ semantic chunking แทน
from llama_index.core.node_parser import SemanticSplitterNodeParser

semantic_parser = SemanticSplitterNodeParser(
    buffer_size=1,
    breakpoint_percent_threshold=95,  # แบ่งเมื่อความคล้ายคลึงลดลง 95%
    embed_model=client,              # ใช้ HolySheep สำหรับ embedding
)

กรณีที่ 2: Overlap น้อยเกินไปทำให้ข้อมูลขาดหาย

อาการ: คำตอบมีข้อมูลไม่ครบ โดยเฉพาะเนื้อหาที่อยู่ตรงรอยตัดระหว่าง chunks

# ❌ วิธีผิด: ไม่มี overlap
node_parser = SentenceSplitter(chunk_size=512, chunk_overlap=0)

✅ วิธีถูก: overlap อย่างน้อย 10-15% ของ chunk_size
node_parser = SentenceSplitter(
    chunk_size=512,
    chunk_overlap=64,       # 12.5% overlap — ปกติใช้ 10-20%
)

สำหรับเอกสารทางเทคนิค แนะนำใช้ overlap มากขึ้น
tech_parser = TokenTextSplitter(
    chunk_size=1024,
    chunk_overlap=256,      # 25% overlap สำหรับโค้ดและเทคนิค
    separator="\n\n"        # แบ่งตาม paragraph
)

กรณีที่ 3: ใช้ Separator ผิดทำให้ chunk ไม่สมเหตุสมผล

อาการ: Chunk ตัดคำข้างกลางประโยค หรือรวมหัวข้อที่ไม่เกี่ยวข้องกันเข้าด้วยกัน

# ❌ วิธีผิด: ใช้ separator ที่ไม่เหมาะกับภาษาไทย
node_parser = SentenceSplitter(separator=" ")  # ภาษาไทยใช้ space แปลกๆ

✅ วิธีถูก: ใช้ multi-language splitter
from llama_index.core.node_parser import MultiModalNodeParser

หรือใช้ Language-aware sentence splitter
node_parser = SentenceSplitter(
    chunk_size=512,
    separator=["\n\n", "\n", "। ", "।", ". "],  # รองรับหลายภาษา
)

สำหรับ HTML/Markdown documents
from llama_index.core.node_parser import HTMLNodeParser

html_parser = HTMLNodeParser(
    tags=["p", "h1", "h2", "h3", "li"],  # แบ่งตามโครงสร้าง HTML
)

กรณีที่ 4: Metadata หายเมื่อใช้ VectorStoreIndex

อาการ: metadata ที่กำหนดไว้หายไปหลังจากสร้าง index หรือ retrieval ไม่สามารถ filter ตาม metadata ได้

# ❌ วิธีผิด: metadata ไม่ถูกเก็บใน vector store
nodes = node_parser.get_nodes_from_documents(documents)
nodes มี metadata แต่ index ไม่ได้เก็บ

✅ วิธีถูก: ตรวจสอบว่า metadata ถูกเก็บใน service context
from llama_index.core import ServiceContext, VectorStoreIndex

service_context = ServiceContext.from_defaults(
    embed_model="local",  # หรือ HolySheep embedding
    # ตรวจสอบว่า node_parser ใช้งาน metadata
)

index = VectorStoreIndex(
    nodes,
    service_context=service_context,
    metadata_fields=["category", "product_id", "price"]  # ระบุ metadata ที่ต้องการ
)

Query พร้อม filter
retriever = index.as_retriever(
    filters=["category", "==", "อิเล็กทรอนิกส์"],
    similarity_top_k=3
)

ตรวจสอบ metadata หลัง retrieval
results = retriever.retrieve("สินค้าราคาเท่าไหร่")
for node in results:
    print(f"Content: {node.text}")
    print(f"Metadata: {node.metadata}")

สรุป: เลือกกลยุทธ์ตาม Use Case

• FAQ/นโยบายสั้น: ใช้ Sentence Splitter กับ chunk_size 256-512
• เอกสารยาว: ใช้ Token Splitter หรือ Hierarchical กับ chunk_size 1024-2048
• โค้ด/เทคนิค: ใช้ overlap สูง (20-25%) และ separator ตาม syntax
• Multi-language: ใช้ Language-aware splitter หรือกำหนด multi-separator

การ optimize node splitting เป็นพื้นฐานที่สำคัญที่สุดของ RAG system ที่มีประสิทธิภาพ หากต้องการทดลองใช้งาน AI API ราคาประหยัด ผมแนะนำ สมัครที่นี่ รับเครดิตฟรีเมื่อลงทะเบียน รองรับทั้ง GPT-4.1, Claude Sonnet 4.5 และ Gemini 2.5 Flash พร้อม latency ต่ำกว่า 50ms ราคาเริ่มต้นเพียง $0.42/MTok สำหรับ DeepSeek V3.2

หากมีคำถามหรือต้องการ consultation เพิ่มเติม สามารถติดต่อ HolySheep AI ได้โดยตรงที่ https://www.holysheep.ai

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