ทำ On-Premise RAG ใช้เองง่าย ๆ ด้วย Ollama และ Python

เตรียมของที่ต้องใช้กันก่อน

Python 3.12

เป็น programming language ตัวนึงที่เราจะใช้วันนี้ เพราะว่าเราจะทำ RAG ขึ้นมาจากโค้ด python กัน https://www.python.org/downloads/

วิธีที่แนะนำในการติดตั้งคือ ใช้ pyenv นะครับ จะได้ control python version ง่าย ๆ https://github.com/pyenv/pyenv

# for macos
brew install pyenv
# then install python 3.12
pyenv install 3.12

Ollama

เป็น tool สำหรับ run LLM model บนเครื่องคอมของเรา https://ollama.com/

Qdrant

เป็น database ที่ออกแบบมาเพื่อเก็บและค้นหาข้อมูลด้วย vector, ผมแนะนำให้ติดตั้งด้วย container (ไม่ว่าจะเป็น docker หรือ podman ครับ)

# podman
podman run -p 6333:6333 -p 6334:6334 -v $(pwd)/qdrant:/qdrant/storage qdrant/qdrant

# or docker
docker run -p 6333:6333 -p 6334:6334 -v $(pwd)/qdrant:/qdrant/storage qdrant/qdrant

เอกสาร PDF สักอัน

เอกสารตัวนี้เป็นข้อมูลที่เราจะนำมาทำ RAG ของเราครับ

สำหรับบทความนี้ ผมจะขอใช้เอกสารจาก Ig Nobel: On the rheology of cats เป็น paper ที่ศึกษาว่า เอ แมวเป็นของเหลวป่ะนะ

เข้าใจการทำงานของ RAG แบบพื้นฐาน

ภาพรวมของ RAG

ลองทำความเข้าใจแต่ละส่วนกัน

จากภาพด้านบน ลองมองเป็นสองส่วนนะครับ

1. เตรียมข้อมูลในรูปแบบที่ LLM เข้าใจและหาได้ง่าย (เส้นเขียว)

• คือการแปลงเอกสาร PDF ของเราให้เป็นข้อความยาว ๆ ก่อน
• จากนั้นจึงแบ่งเป็น chunk
• แล้วนำไปทำ embedding เพื่อจัดเก็บข้อมูลใน vector database ซึ่งเป็น database เฉพาะที่เอาไว้เก็บ vector ของข้อความ

2. นำ prompt ของ user ไปค้นหาส่วนของเอกสารที่เกี่ยวของกับ prompt (เส้นส้ม)

• User จะ prompt เข้ามาในระบบของเรา
• เราจะนำข้อความนี้ไปทำ embedding เพื่อเอา vector ไปหาต่อใน vector database เพื่อหาส่วนของข้อมูลที่ใกล้เคียงกัน
• จากนั้นก็เอาข้อมูลที่ได้จาก vector database มารวมกับ prompt ของเราและ user ก่อนที่จะส่งไปให้ LLM ตอบคำถามต่อไป

ใน section นี้ เป้าหมายของเราคือ เราอยากจะมี command line สักตัวที่เราสามารถเรียกถามคำถามได้ไว ๆ เช่น

python ask.py "Is cat a liquid?"

ใน ask.py จะเป็น file ที่เราเอาไว้ถาม RAG system ของเรา

import sys
from openai import OpenAI
from qdrant_client import QdrantClient
from constants import (
    OPENAI_URL,
    OPENAI_API_KEY,
    QDRANT_URL,
    QDRANT_PORT,
)

from rag import RAG

def ask(question: str):

    # เตรียม client สำหรับ OpenAI และ Qdrant
    ollama_client = OpenAI(base_url=OPENAI_URL, api_key=OPENAI_API_KEY)
    qdrant_client = QdrantClient(url=QDRANT_URL, port=QDRANT_PORT, prefer_grpc=True)

    # เรียกใช้ RAG
    rag = RAG(ollama_client, qdrant_client)
    response = rag.ask(question)

    print(f"\nResponse to query '{question}':\n\n {response}")
    
    return response

if __name__ == "__main__":

    # รับคำถามจาก command line
    if len(sys.argv) != 2:
        print("Usage: python ask.py <question>")
        sys.exit(1)
    question = sys.argv[1]

    # ถามเลย!
    ask(question)

ในไฟล์ rag.py จะมี class RAG ที่มี method อยู่สองตัว เพื่อดึงข้อมูลที่เกี่ยวข้องจาก vector database (get_relevant_documents), และเพื่อถาม RAG ของเรา (ask)

from openai import OpenAI
from qdrant_client import QdrantClient
from constants import (
    LLM_MODEL, 
    EMBEDDING_MODEL, 
    COLLECTION_NAME,
)

class RAG:

    # ตัว init ของ class
    def __init__(self, openai_client: OpenAI, qdrant_client: QdrantClient):
        self.openai_client = openai_client
        self.qdrant_client = qdrant_client

    # function เพื่่อค้นหาเอกสารที่เกี่ยวข้องจากฐานข้อมูล
    def get_relevant_documents(self, query: str, limit=5):
        # เอา prompt ไปสร้าง embedding
        query_embedding = self.openai_client.embeddings.create(
            model=EMBEDDING_MODEL,
            input=query
        ).data[0].embedding
        
        # เอา vector ที่ได้ไปค้นหาในฐานข้อมูล
        search_results = self.qdrant_client.query_points(
            collection_name=COLLECTION_NAME,
            query=query_embedding,
            limit=limit
        )
        
        # เอาข้อมูลที่ได้จากการค้นหา (search results) มาเก็บใน context_texts
        context_texts = [hit.payload["text"] for hit in search_results.points]
        return context_texts

    # function สำหรับถาม RAG ของเรา
    def ask(self, query: str) -> str:
        # ค้นหาเอกสารที่เกี่ยวข้องจากฐานข้อมูล
        context_docs = self.get_relevant_documents(query)
        
        # เอา context_docs มาต่อกัน
        context_text = "\n\n".join(context_docs)
        
        # สร้าง prompt สำหรับถาม LLM
        prompt = f"""
            You are an expert on the rheology of cat. Answer the following question using ONLY the information in the context. If the answer is not in the context, say "I don't know".
            Do not mention the context in your answer.

            CONTEXT INFORMATION: {context_text}
            USER QUESTION: {query}
            """

        # ถาม LLM ของเราเลย!
        response = self.openai_client.chat.completions.create(
            model=LLM_MODEL,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.2,
        )
        
        return response.choices[0].message.content

ลองถาม RAG ของเรากัน!

RAG ของเรายอมรับแล้วว่าแมวเป็นของเหลว (😂😂😂😂😂😂)

ครอบ UI ให้น้องสักหน่อย

ครั่นจะให้เอา command line ไปให้ user ใช้ก็อาจจะดูไม่ค่อย user-friendly เท่าไหร่ เรามาลองครอบ RAG application ของเราด้วย UI ง่าย ๆ ไว ๆ กัน มี lib อยู่ตัวนึงที่ผมชอบมาก ๆ เพราะมันขึ้นได้ไวสุด ๆ ก็คือ https://streamlit.io/

ในไฟล์ app.py ที่ทำหน้าที่เป็น UI creator ของเรา

import streamlit as st
from ask import ask

# ตั้งค่า Streamlit page
st.set_page_config(
    page_title="Cat Rheology RAG Assistant",
    page_icon="🐱",
    layout="centered"
)

st.title("Cat Rheology RAG Assistant")

question = st.text_input("Ask a question about cat rheology:", key="question_input")

submit_button = st.button("Get Answer")

if submit_button and question:
    with st.spinner('Retrieving information...'):
        response = ask(question)
    
    st.subheader("Answer:")
    st.write(response)
    
    with st.expander("Your question"):
        st.write(question)
    
elif submit_button and not question:
    st.warning("Please enter a question.")

แล้วเราก็สั่งไปเลยว่า

streamlit run app.py

แค่นี้ก็ได้ UI Interface สำหรับ RAG application ของเราแล้ว!

สำหรับตัว code เต็ม ๆ สามารถไปส่องได้ที่นี่เลย https://github.com/kasidis-palo/basic-rag

FAQ

ทำไมต้องแบ่งข้อความเป็นท่อน ๆ (chunk) ก่อนทำ embedding ด้วยล่ะ?

มี 3 สาเหตุหลัก ๆ ครับ คือ

• LLM ที่เราทำงานด้วย มันมี token limit อยู่ ถ้าเราใส่ไปทั้งหมด ข้อความมันจะยาวเกิน token แล้วก็จะไม่ถูกเอาไปคิด
• ทำให้ RAG ตอบคำถามตรงจุดขึ้น เพราะเราจะเอาแค่ chunk ของข้อความที่เกี่ยวข้อง (จากการไป query vector database) มาใส่ใน context ของเรา
• มันประหยัดพลังงานกว่า!

TextSplitter คืออะไร มีตัวอื่นด้วยหรอ

TextSplitter คือเครื่องมือที่ช่วยแบ่งข้อความยาว ๆ ออกเป็นท่อนสั้น ๆ เพื่อให้ Large Language Model (LLM) ทำงานได้ดีขึ้น แต่การแบ่งข้อความก็มีหลายทางเหมือนกัน และต้องเลือกใช้ตามความเหมาะสมของข้อมูลเรา เช่น

• RecursiveCharacterTextSplitter (ตัวที่ใช้ในบทความนี้) — แบ่งตามตัวแบ่งเช่น เว้นบรรทัด ช่องว่าง ซึ่งเหมาะกับบทความ เอกสาร PDF ทั่ว ๆ ไป
• MarkdownHeaderTextSplitter — แบ่งตามโครงสร้างหัวข้อของ Markdown เช่น #, ##, ### เพื่อรักษาลำดับของเนื้อหา
• HTMLHeaderTextSplitter — แบ่งตาม tag หัวข้อใน HTML เช่น <h1>, <h2>, <h3> เหมาะกับการดึงข้อมูลจาก website

Summary

วันนี้เราได้ลองนำข้อมูลจาก PDF มาต่อยอดให้ LLM ตอบคำถามได้ฉลาดขึ้น (จนสามารถ convince ได้ว่าแมวเป็นของเหลวจริง ๆ) พร้อมสร้าง RAG application ใช้งานเองได้แบบง่าย ๆ บนเครื่องของเราเอง และนี่เป็นแค่จุดเริ่มต้น

ในโลกของ RAG ยังมีเรื่องของการ validation, evaluation และ optimisation ที่น่าสนใจอีกมาก รอติดตามเนื้อหาสนุก ๆ จาก PALO IT กันได้เลยครับ!