การนำ RAG ไปใช้งานขั้นพื้นฐาน: บทช่วยสอนทีละขั้นตอน

บทช่วยสอนสำหรับผู้เริ่มต้นนี้อธิบายวิธีการทำงานของการนำ RAG ไปใช้งานขั้นพื้นฐาน ครอบคลุมแนวทางปฏิบัติที่ดีที่สุด และแนะนำการสร้างระบบ RAG แบบบรรทัดคำสั่งที่ใช้งานได้จริงด้วย Python, ChromaDB รวมถึงโมเดลเอ็มเบดดิงและโมเดลภาษาของ Perplexity

Basic RAG implementation process diagram: the interface sends input to the orchestrator, which retrieves data from a vector database, builds the input context for the LLM, and returns the output to the interface.

RAG เป็นองค์ประกอบสำคัญของโครงสร้างพื้นฐานยุคใหม่ที่ใช้ LLM การเปิดให้โมเดล AI เข้าถึงข้อมูลภายนอกได้ช่วยแก้ปัญหาต่างๆ เช่น อาการหลอน (hallucination) และข้อมูลฝึกที่ไม่ครบถ้วน นอกจากนี้ยังทำให้บริษัทต่างๆ สามารถใช้ฐานความรู้ภายในที่มีข้อมูลละเอียดอ่อนหรือข้อมูลที่เป็นกรรมสิทธิ์ได้

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

ในบทความนี้ เราจะวางโครงร่างการนำ RAG ขั้นพื้นฐานไปใช้งาน อธิบายแนวทางปฏิบัติที่ดีที่สุด แล้วสร้างระบบที่ใช้งานได้จริงโดยใช้ Python, ChromaDB และโมเดลของ Perplexity สองตัวสำหรับการสร้างเอ็มเบดดิงและการสร้างคำตอบ

กระบวนการนำ RAG ขั้นพื้นฐานไปใช้งาน: ภาพรวมระดับสูง

ระบบ RAG ขั้นพื้นฐานมีองค์ประกอบหลักสามส่วน ได้แก่ ออร์เคสเตรเตอร์ (orchestrator) แหล่งข้อมูล และ LLM ในเวิร์กโฟลว์ทั่วไป ผู้ใช้จะป้อนพรอมต์ จากนั้นออร์เคสเตรเตอร์จะปรับแก้พรอมต์นั้นเพื่อค้นหาในแหล่งข้อมูลที่เชื่อมต่ออยู่ ข้อมูลที่ดึงมาได้จะถูกเพิ่มลงในบริบทอินพุตเดิมและส่งไปยัง LLM เพื่อสร้างคำตอบ

คุณจะต้องคำนึงถึงขั้นตอนเหล่านี้เมื่อสร้างระบบ RAG ของคุณ:

  1. การทำดัชนีและการสร้างเอ็มเบดดิง: ในขั้นนี้ เอกสารของคุณจะถูกแปลงเป็นแหล่งข้อมูลที่ออร์เคสเตรเตอร์สามารถค้นหาได้ วิธีที่นิยมที่สุดวิธีหนึ่งคือการสร้างดัชนีเวกเตอร์ที่ค้นหาได้ เราจะใช้โมเดลเฉพาะทางจาก Perplexity เพื่อแปลงชิ้นส่วนเอกสาร (chunk) ของคุณให้เป็นเอ็มเบดดิง จากนั้นจะจัดเก็บเอ็มเบดดิงด้วย ChromaDB ซึ่งเป็นฐานข้อมูลเวกเตอร์แบบโอเพนซอร์สที่ได้รับความนิยม
  2. การประสานงาน (Orchestration): นี่คือแอปพลิเคชันที่อยู่ระหว่างแหล่งข้อมูลภายนอก (ในกรณีของเราคือฐานข้อมูลเวกเตอร์) กับ LLM เราจะสร้างสคริปต์ Python อย่างง่ายเพื่อทำหน้าที่เป็นออร์เคสเตรเตอร์
  3. การดึงข้อมูลและการสร้างคำตอบ: เมื่อผู้ใช้ถามคำถามผ่านอินเทอร์เฟซแชท ออร์เคสเตรเตอร์จะรับคำถามนั้นไป เรียกใช้การค้นหาเวกเตอร์ และส่งอินพุตที่ขยายแล้วไปยัง LLM เราจะใช้บรรทัดคำสั่งในการป้อนพรอมต์เพื่อสื่อสารกับออร์เคสเตรเตอร์ Python ของเรา แทนการสร้างฟรอนต์เอนด์โดยเฉพาะ

แนวทางปฏิบัติที่ดีที่สุด: อะไรทำให้การนำ RAG ไปใช้งานมีประสิทธิภาพ

สถาปัตยกรรม RAG มีหลายประเภท และกรณีการใช้งานแต่ละแบบก็ต้องการแนวทางที่แตกต่างกัน อย่างไรก็ตาม มีแนวทางปฏิบัติที่ดีที่สุดหลายข้อที่ใช้ได้ในทุกกรณี และช่วยให้ระบบมีความแม่นยำ คุ้มค่า ปรับขนาดได้ และดูแลรักษาได้ง่าย

แนวทางปฏิบัติที่ดีที่สุดต่อไปนี้ใช้ได้กับการนำ RAG ไปใช้งานทุกประเภท:

  • ดูแลให้ไปป์ไลน์การนำเข้าข้อมูลสะอาด: ข้อมูลต้นทางของคุณควรสะอาดที่สุดเท่าที่จะเป็นไปได้ก่อนทำดัชนี และคุณควรใช้โมเดลเอ็มเบดดิงที่เหมาะกับเนื้อหาของคุณด้วย
  • ใช้การค้นหาแบบไฮบริด: วิธีการดึงข้อมูลที่ดีที่สุด ไม่ว่าจะเป็นการค้นหาในฐานข้อมูลเวกเตอร์ การค้นหาเว็บผ่าน API การท่องกราฟความรู้ การค้นหาด้วยคีย์เวิร์ด หรือวิธีอื่นๆ จะแตกต่างกันไปตามกรณีการใช้งาน การเลือกผสมผสานวิธีที่เหมาะสมจึงสำคัญต่อการลดต้นทุน
  • ประเมินระบบของคุณ: หลังจากนำไปใช้งานแล้ว คุณควรประเมินตามตัวชี้วัดหลักสามด้าน ได้แก่ ความแม่นยำ ความเกี่ยวข้อง และเวลาแฝง ความแม่นยำหมายถึงความถูกต้องของข้อเท็จจริง ความเกี่ยวข้องหมายถึงความเหมาะสมของข้อมูลที่ดึงมากับคำค้นหาของผู้ใช้ และเวลาแฝงหมายถึงความเร็วในการดึงข้อมูล
  • จัดการข้อมูลอย่างปลอดภัย: หากระบบ RAG ของคุณใช้ข้อมูลภายในที่เป็นความลับ ให้ตรวจสอบว่าข้อมูลนั้นถูกจัดเก็บอย่างปลอดภัย และมีการควบคุมสิทธิ์การเข้าถึงอินเทอร์เฟซของระบบ ห้ามแชร์คีย์ API โดยเด็ดขาด

การนำ RAG ไปใช้งานขั้นพื้นฐาน: บทช่วยสอน 7 ขั้นตอน

ในบทช่วยสอนนี้ เราจะสร้างแอปพลิเคชันบรรทัดคำสั่งที่ตอบคำถามเกี่ยวกับเอกสารฉบับเดียว โดยใช้ Python, ChromaDB และ Perplexity API

เป้าหมายไม่ใช่การสร้างระบบ RAG ที่พร้อมใช้งานจริงในระดับโปรดักชัน แต่เป็นบทช่วยสอนที่เหมาะสำหรับผู้เริ่มต้น ซึ่งออกแบบมาเพื่อแสดงให้เห็นว่าสถาปัตยกรรม RAG ขั้นพื้นฐานทำงานอย่างไรในทางปฏิบัติ

ขั้นตอนที่ 1: ติดตั้งซอฟต์แวร์

ตรวจสอบให้แน่ใจว่าคอมพิวเตอร์ของคุณติดตั้งสิ่งต่อไปนี้แล้ว และคุณมีบัญชี Perplexity API:

  • Python: นี่คือภาษาโปรแกรมที่เราจะใช้สร้างออร์เคสเตรเตอร์ ซึ่งจะประสานการไหลของข้อมูลระหว่างโมเดลเอ็มเบดดิง ChromaDB และ Perplexity
  • Visual Studio: เราจะใช้ Visual Studio เป็นโปรแกรมแก้ไขโค้ด เมื่อติดตั้งแล้ว ให้เปิดแผง Extensions และดาวน์โหลดส่วนขยาย Python
  • บัญชี Perplexity API: Perplexity จะให้บริการทั้งโมเดลเอ็มเบดดิง (ซึ่งแปลงข้อมูลของคุณเป็นเวกเตอร์เอ็มเบดดิง) และ LLM ที่จะประมวลผลพรอมต์ที่ขยายแล้ว คุณไม่จำเป็นต้องมีบัญชีแบบชำระเงินในการทำสิ่งนี้ แต่จะมีการใช้เครดิตเล็กน้อย

ขั้นตอนที่ 2: สร้างโฟลเดอร์โปรเจกต์

เริ่มต้นด้วยการสร้างโฟลเดอร์ชื่อ rag-project แล้วเปิดโฟลเดอร์นี้ใน VS Code โดยเลือก File > Open Folder จากนั้นเปิดเทอร์มินัลในตัวผ่าน Terminal > New Terminal

ป้อนคำสั่งต่อไปนี้เพื่อสร้างสภาพแวดล้อมเสมือนของ Python:

bash
py -3.12 -m venv .venv

ตอนนี้คุณต้องติดตั้งไลบรารี Python สี่รายการ ได้แก่ perplexityai, chromadb, python-dotenv และ numpy โดย Perplexity SDK จะช่วยให้คุณเชื่อมต่อกับโมเดลของ Perplexity ผ่าน API ได้ ChromaDB จะสร้างฐานข้อมูลเวกเตอร์และทำงานบนเครื่องของคุณ Python-dotenv จะโหลดคีย์ API ของคุณจากไฟล์ในเครื่องอย่างปลอดภัย ส่วน NumPy จำเป็นต้องใช้ในระหว่างกระบวนการนำเข้าข้อมูล

ติดตั้งไลบรารีเหล่านี้ด้วยคำสั่งต่อไปนี้:

bash
.\.venv\Scripts\python.exe -m pip install perplexityai chromadb python-dotenv numpy

ขั้นตอนที่ 3: ตั้งค่าไฟล์ของคุณ

เพิ่มไฟล์ต่อไปนี้ลงใน rag-project (รูทของโปรเจกต์) โดยเลือก New File… ในแถบด้านข้าง Explorer:

  • index.py: นี่คือแอปพลิเคชันที่จะทำดัชนีเอกสารของคุณ คุณสามารถเรียกใช้ซ้ำเพื่อเพิ่มข้อความเพิ่มเติมได้
  • rag.py: นี่คือแอปพลิเคชัน Python ที่จะทำหน้าที่เป็นออร์เคสเตรเตอร์
  • document.txt: ไฟล์นี้จะเก็บเอกสารที่คุณจะแปลงเป็นฐานข้อมูลเวกเตอร์
  • .env: ไฟล์นี้คือที่ที่คุณจะเก็บคีย์ Perplexity API ของคุณ

ใน .env ให้ป้อนข้อมูลต่อไปนี้:

plaintext
PERPLEXITY_API_KEY=your_api_key_here

แทนที่ your_api_key_here ด้วยคีย์จริงของคุณ โดยไปที่แดชบอร์ดหน้าแรกของ Perplexity API Console แล้วเลือก Create an API key เก็บคีย์ API นี้ไว้เป็นความลับ

เราจะใช้โมเดลสองตัว ได้แก่ pplx-embed-v1-0.6b ของ Perplexity เพื่อสร้างเอ็มเบดดิงจากเอกสารของเราก่อนอัปโหลดไปยัง ChromaDB และ GPT-5.6-Luna (เข้าถึงผ่าน API ของ Perplexity) ซึ่งจะประมวลผลข้อมูลที่ดึงมาได้

ใน document.txt ให้เพิ่มข้อความที่ไปป์ไลน์ RAG ของคุณจะใช้ดึงข้อมูล หากคุณไม่มีเอกสารอยู่ในมือ ให้ใช้ Songs of Innocence and of Experience ของ William Blake จาก Project Gutenberg สำหรับบทช่วยสอนนี้ ซึ่งเป็นข้อความสั้นๆ ที่เข้าใจง่ายและเป็นสาธารณสมบัติ

ขั้นตอนที่ 4: เขียนโปรแกรมทำดัชนี

คัดลอกและวางโค้ดด้านล่างลงใน index.py หัวข้อย่อยแต่ละหัวข้อจะอธิบายสั้นๆ ว่าโค้ดส่วนถัดไปทำอะไร นี่คือโปรแกรมที่จะแปลงเนื้อหาต้นทางของคุณเป็นเวกเตอร์เอ็มเบดดิงและจัดเก็บไว้ในฐานข้อมูล ChromaDB โดยใช้โมเดลเอ็มเบดดิงของ Perplexity คือ pplx-embed-v1-0.6b และไลบรารี NumPy

สิ่งที่โปรแกรมนี้ทำมีดังนี้:

  1. เปิด document.txt
  2. แบ่งข้อความออกเป็นชิ้นส่วนที่ซ้อนทับกัน
  3. ส่งชิ้นส่วนเหล่านั้นไปยังโมเดลเอ็มเบดดิง pplx-embed-v1-0.6b ของ Perplexity
  4. ถอดรหัสและนอร์มัลไลซ์เวกเตอร์ที่ได้รับกลับมาโดยใช้ NumPy ซึ่งเป็นไลบรารี Python สำหรับฟังก์ชันการคำนวณ
  5. จัดเก็บเวกเตอร์และชิ้นส่วนต้นฉบับไว้ในฐานข้อมูล ChromaDB (คุณจะเห็นฐานข้อมูลนี้ปรากฏในไดเรกทอรีโปรเจกต์ของคุณ)

โปรแกรมนี้ได้รับการตั้งค่าไว้ไม่ให้ทำดัชนีเอกสารของคุณใหม่ทุกครั้งที่เรียกใช้ หากคุณเพิ่มข้อมูลใน document.txt โปรแกรมจะสร้างเอ็มเบดดิงเฉพาะข้อความใหม่เท่านั้น

python
from pathlib import Path from collections import defaultdict, deque from hashlib import sha256 import base64 import numpy as np import chromadb from dotenv import load_dotenv from perplexity import Perplexity # 1. Connect to Perplexity and ChromaDB load_dotenv() ai = Perplexity() db = chromadb.PersistentClient(path="./rag_database_perplexity") collection = db.get_or_create_collection( name="documents", metadata={"hnsw:space": "cosine"} ) # Convert Perplexity's encoded embeddings into numerical vectors def decode_embedding(encoded): vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32) norm = np.linalg.norm(vector) if norm == 0: raise ValueError("Received a zero-length embedding vector.") return (vector / norm).tolist() # 2. Read the document and split it into chunks text = Path("document.txt").read_text(encoding="utf-8") words = text.split() chunk_size = 180 overlap = 30 step = chunk_size - overlap chunks = [" ".join(words[i:i + chunk_size]) for i in range(0, len(words), step)] if not chunks: raise ValueError("document.txt is empty.") # 3. Retrieve the chunks already stored in ChromaDB existing = collection.get(include=["documents"]) stored_chunks = defaultdict(deque) existing_ids = set(existing["ids"]) for chunk_id, document in zip(existing["ids"], existing["documents"]): stored_chunks[document].append(chunk_id) # 4. Identify unchanged and new chunks new_chunks = [] new_ids = [] kept_ids = set() unchanged = 0 for chunk in chunks: if stored_chunks[chunk]: chunk_id = stored_chunks[chunk].popleft() kept_ids.add(chunk_id) unchanged += 1 else: chunk_hash = sha256(chunk.encode("utf-8")).hexdigest() chunk_id = f"chunk-{chunk_hash}" suffix = 1 while chunk_id in existing_ids or chunk_id in kept_ids or chunk_id in new_ids: chunk_id = f"chunk-{chunk_hash}-{suffix}" suffix += 1 new_chunks.append(chunk) new_ids.append(chunk_id) kept_ids.add(chunk_id) # 5. Generate embeddings in batches of up to 100 chunks batch_size = 100 for i in range(0, len(new_chunks), batch_size): batch_chunks = new_chunks[i:i + batch_size] batch_ids = new_ids[i:i + batch_size] embeddings = ai.embeddings.create( model="pplx-embed-v1-0.6b", input=batch_chunks, encoding_format="base64_int8" ) vectors = [decode_embedding(item.embedding) for item in embeddings.data] # 6. Store each batch in ChromaDB collection.upsert( ids=batch_ids, documents=batch_chunks, embeddings=vectors ) print(f"Indexed batch {(i // batch_size) + 1}") # 7. Remove outdated chunks old_ids = [chunk_id for chunk_id in existing["ids"] if chunk_id not in kept_ids] if old_ids: collection.delete(ids=old_ids) # 8. Display indexing results print("Indexing complete!") print("Unchanged chunks:", unchanged) print("New or modified chunks:", len(new_chunks)) print("Removed chunks:", len(old_ids)) print("Total stored chunks:", collection.count())

ขั้นตอนที่ 5: เขียนออร์เคสเตรเตอร์สำหรับระบบ RAG

คัดลอกและวางโค้ดด้านล่างลงใน rag.py โค้ดนี้เป็นการนำ RAG ไปใช้งานที่สมบูรณ์แต่เรียบง่าย โดยใช้ Perplexity SDK และฟังก์ชันฐานข้อมูลเวกเตอร์ภายในเครื่องของ ChromaDB

สิ่งที่จะเกิดขึ้นเมื่อคุณเรียกใช้โปรแกรมมีดังนี้:

  1. เชื่อมต่อกับ Perplexity และฐานข้อมูล ChromaDB ใหม่ของคุณ
  2. ตรวจสอบว่าฐานข้อมูลมีเอกสารที่ทำดัชนีแล้ว
  3. รับคำถามจากผู้ใช้
  4. ส่งคำถามไปยังโมเดลเอ็มเบดดิงของ Perplexity
  5. ถอดรหัสและนอร์มัลไลซ์เอ็มเบดดิงที่ได้โดยใช้ NumPy
  6. ค้นหาชิ้นส่วนเอกสารที่คล้ายกันมากที่สุดสามชิ้นใน ChromaDB
  7. สร้างพรอมต์ที่มีชิ้นส่วนที่ดึงมาได้และคำถามของผู้ใช้
  8. ส่งพรอมต์ไปยัง GPT-5.6 Luna ผ่าน Agent API ของ Perplexity
  9. แสดงคำตอบและรอคำถามถัดไป
python
import base64 import numpy as np import chromadb from dotenv import load_dotenv from perplexity import Perplexity # 1. Connect to Perplexity and the existing ChromaDB database load_dotenv() ai = Perplexity() db = chromadb.PersistentClient(path="./rag_database_perplexity") collection = db.get_collection("documents") # Convert Perplexity's encoded embeddings into numerical vectors def decode_embedding(encoded): vector = np.frombuffer(base64.b64decode(encoded), dtype=np.int8).astype(np.float32) norm = np.linalg.norm(vector) if norm == 0: raise ValueError("Received a zero-length embedding vector.") return (vector / norm).tolist() # 2. Check that the database contains indexed documents count = collection.count() if count == 0: raise ValueError("The database is empty. Run index.py first.") print("Connected to existing ChromaDB database.") print("Stored chunks:", count) # 3. Accept questions from the user while True: question = input("\nAsk a question (or type exit): ") if question.lower().strip() == "exit": break if not question.strip(): continue # 4. Convert the question into a Perplexity embedding question_response = ai.embeddings.create( model="pplx-embed-v1-0.6b", input=[question], encoding_format="base64_int8" ) question_vector = decode_embedding(question_response.data[0].embedding) # 5. Retrieve the most similar document chunks from ChromaDB results = collection.query( query_embeddings=[question_vector], n_results=min(3, count) ) context = "\n\n".join(results["documents"][0]) # 6. Construct a prompt and send it to the fixed LLM response = ai.responses.create( model="openai/gpt-5.6-luna", instructions=( "Answer using only the supplied document excerpts. " "Do not use external information. " "If the answer is not present, say you don't know." ), input=f"Document excerpts:\n{context}\n\nQuestion: {question}" ) # 7. Display the answer print("\nAnswer:\n", response.output_text)

ขั้นตอนที่ 6: เรียกใช้แอปพลิเคชัน

ในเทอร์มินัล PowerShell ของ VS Code ให้ป้อนคำสั่งต่อไปนี้เพื่อสร้างเอ็มเบดดิงจากเนื้อหาใน document.txt:

bash
.\.venv\Scripts\python.exe index.py

หากทำดัชนีเอกสารสำเร็จ คุณจะเห็นเอาต์พุตที่คล้ายกับตัวอย่างนี้:

plaintext
Indexing complete! Unchanged chunks: 0 New or modified chunks: 58 Removed chunks: 0 Total stored chunks: 58

ถึงเวลาเรียกใช้แอปพลิเคชันออร์เคสเตรเตอร์หลักแล้ว ป้อนคำสั่งนี้:

bash
.\.venv\Scripts\python.exe rag.py

หากเรียกใช้สำเร็จ คุณจะเห็นข้อความต่อไปนี้:

plaintext
Connected to existing ChromaDB database. Stored chunks: 58 Ask a question (or type exit):

ตอนนี้คุณสามารถถามคำถามที่จะดึงข้อมูลจากฐานข้อมูลเวกเตอร์ที่คุณสร้างขึ้นได้แล้ว เช่น:

plaintext
Ask a question (or type exit): What animals does William Blake talk about? Answer: The excerpts mention sheep, lambs, birds, beasts, wolves, tigers, and a lion.

ขั้นตอนที่ 7: ทำความเข้าใจสิ่งที่คุณสร้างขึ้น

ระบบที่คุณสร้างขึ้นประกอบด้วยไปป์ไลน์หลักสองส่วนที่มีอยู่ในสถาปัตยกรรม RAG ทุกรูปแบบ ได้แก่ ไปป์ไลน์การทำดัชนีหรือ “การนำเข้าข้อมูล” (ingestion) และไปป์ไลน์การดึงข้อมูลและการสร้างคำตอบ

ตอนนี้ระบบ RAG ขั้นพื้นฐานของคุณทำสิ่งต่อไปนี้ได้ทั้งหมด:

  • การจัดเก็บเวกเตอร์: เอ็มเบดดิงที่สร้างจากไฟล์ความรู้ของคุณจะถูกบันทึกไว้ในฐานข้อมูล ChromaDB ในสภาพแวดล้อมภายในเครื่องของคุณ
  • การทำดัชนีแบบเพิ่มทีละส่วน: ชิ้นส่วนเอกสารที่ไม่มีการเปลี่ยนแปลงจะไม่ถูกสร้างเอ็มเบดดิงซ้ำ และคุณสามารถอัปเดตเอกสารได้ทุกเมื่อที่ต้องการ
  • การดึงข้อมูลเชิงความหมาย: ChromaDB จะดึงชิ้นส่วนตามความคล้ายคลึงของเวกเตอร์ (โดยออร์เคสเตรเตอร์เป็นผู้เริ่มการทำงาน)
  • การสร้างคำตอบที่อิงข้อมูลอ้างอิง: LLM จะได้รับข้อความที่ดึงมาเป็นบริบท และนำไปใช้ประกอบในคำตอบ
  • การทำดัชนีและการค้นหาที่แยกจากกัน: คุณสามารถถามคำถามได้โดยไม่ต้องประมวลผลข้อความทั้งหมดในไฟล์ความรู้ของคุณใหม่
  • การเชื่อมต่อโมเดลผ่าน API: คำตอบทั้งหมดสร้างขึ้นโดยใช้ GPT-5.6 Luna ผ่าน Perplexity แทนที่จะใช้โมเดลที่ทำงานบนเครื่องของคุณ

ขั้นตอนถัดไป: วิธีต่อยอดระบบนี้ให้ก้าวหน้ายิ่งขึ้น

เป้าหมายของบทช่วยสอนนี้คือการสร้างระบบขั้นพื้นฐานที่ตรงไปตรงมา ซึ่งครอบคลุมองค์ประกอบหลักบางส่วนของสถาปัตยกรรม RAG ที่มีอยู่ในระบบยุคใหม่ หากคุณต้องการไปให้ไกลกว่านี้ ก็มีหลายวิธีที่คุณสามารถต่อยอดได้

ต่อไปนี้คือแนวคิดบางส่วนสำหรับการขยายขอบเขตของระบบของคุณ:

  • ทดลองใช้ LangChain: LangChain เป็นหนึ่งในเฟรมเวิร์กการประสานงานแบบโอเพนซอร์สที่ได้รับความนิยมมากที่สุด โดยมีคอมโพเนนต์สำเร็จรูปสำหรับสร้างแอปที่สามารถรันไปป์ไลน์ RAG ที่ซับซ้อนได้
  • ขยายฟังก์ชันการค้นหา: ผสานการค้นหาเวกเตอร์แบบหนาแน่น (dense vector search) เข้ากับการค้นหาเชิงคำศัพท์ (คีย์เวิร์ด) เช่น BM25 นอกจากนี้ การเพิ่มการค้นหาเว็บผ่าน Perplexity Search API ยังช่วยให้คุณอ้างอิงคำตอบจากข้อมูลล่าสุดได้ด้วย
  • เพิ่มโมเดลจัดอันดับใหม่ (reranking): ผสานรวมโมเดลจัดอันดับใหม่ที่จัดลำดับข้อความที่ดึงมาโดยเทียบกับพรอมต์เริ่มต้น และเลือกข้อความที่เกี่ยวข้องมากที่สุดเพื่อรวมไว้ในบริบทอินพุตที่ส่งให้ LLM
  • สร้างระบบ RAG แบบปรับตัวได้: Adaptive RAG ใช้ LLM หรือตัวจำแนกประเภท (คอมโพเนนต์หนึ่งภายในออร์เคสเตรเตอร์) เพื่อตัดสินว่าจะใช้วิธีการดึงข้อมูลแบบใดในระบบ RAG แบบโมดูลาร์ การสร้างระบบนี้เป็นวิธีที่ดีในการศึกษาการนำ RAG ไปใช้งานในรูปแบบที่ซับซ้อนยิ่งขึ้น

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

หมายเหตุ: บทช่วยสอนนี้ใช้ GPT-5.6 Luna ความพร้อมใช้งานของโมเดลอาจเปลี่ยนแปลงได้ คุณจึงอาจต้องอัปเดตการเรียกใช้ API