Golang The Series EP.159: Hybrid Search ผสมผสาน SQL และ Vector Search ใน Go

สวัสดีครับชาว Gophers! ต้อนรับเข้าสู่ EP.159

ต่อจากตอนที่แล้วที่เราลุยเรื่อง Context Injection จนระบบ RAG ของเราสามารถดึงคำตอบจากเอกสารได้แบบเนียนๆ กันไปแล้ว แต่พอเอาไปขึ้นระบบใช้งานจริงบน Production ผมเชื่อว่าหลายคนน่าจะเคยเจอ "Pain point" เดียวกันครับ

ปัญหาคือข้อมูลในองค์กรส่วนใหญ่มันไม่ได้มีแค่ไฟล์เอกสารดิบๆ (Unstructured Data) ที่เราจับมาแปลงเป็นเวกเตอร์เพียงอย่างเดียว แต่มันยังมีข้อมูลแบบมีโครงสร้าง (Structured Data) อีกมหาศาลที่นอนอยู่ใน Relational Database แบบดั้งเดิมอย่าง PostgreSQL หรือ MySQL ไม่ว่าจะเป็น สังกัดแผนกของพนักงาน, สิทธิ์การเข้าถึง (Permission Level), วันที่อัปเดตระบบ หรือสถานะของเอกสาร (Active/Draft)

ลองนึกภาพ Requirement จากฝั่ง Business ดูครับ: "อยากให้พนักงานค้นหาคู่มือด้วย AI ได้นะ แต่ล็อกเงื่อนไขว่าต้องดึงมาเฉพาะเอกสารที่เป็นเวอร์ชันล่าสุด และผู้ถามต้องมีสิทธิ์ (Role = Admin) เท่านั้น"

ถ้าเราพึ่งพา Vector DB โดดๆ โดยไม่สนเงื่อนไขอื่น โอกาสที่ข้อมูลความลับจะรั่วไหลข้ามแผนกก็มีสูงมาก นี่แหละครับคือจุดที่ Hybrid Search หรือเทคนิคการผสานโลกของ SQL เข้ากับ Vector Search ต้องออกโรงในแอปพลิเคชัน Go ของเรา!

แนวคิดการออกแบบ Hybrid Search ในโปรเจกต์ Go

เวลาที่เราต้องการกรองข้อมูลข้าม 2 สถาปัตยกรรมนี้ โดยทั่วไปเราสามารถวางโครงสร้างได้ 2 ท่าหลักๆ ครับ:

1. Two-Stage Query (ท่าคลาสสิก: SQL ก่อน แล้วค่อย Vector)

   ท่านี้คือการใช้ Go Backend วิ่งไปคิวรีที่ SQL Database ก่อน เพื่อดึงลิสต์ของ Document ID ที่ผ่านเงื่อนไข (เช่น สิทธิ์ถูกต้อง, สถานะผ่าน) ออกมากองไว้ จากนั้นค่อยนำลิสต์ ID เหล่านั้นส่งไปเป็น Filter ให้ Vector DB ค้นหาต่ออีกทอดหนึ่ง ท่านี้แยกการทำงานชัดเจน แต่ถ้าลิสต์ ID มีขนาดใหญ่มาก อาจทำให้เกิดความหน่วง (Latency) ได้

2. Integrated Filtering หรือ Metadata Pre-filtering (ท่าแนะนำ: จบในดาบเดียว)
   ท่านี้คือการย้ายข้อมูลเงื่อนไขที่จำเป็น (Metadata) ไปบันทึกลงในส่วน Payload ของ Vector Database (เช่น Qdrant) ควบคู่ไปตั้งแต่ตอนสกัดข้อมูลเลย จากนั้นใช้ฟีเจอร์ Payload Indexing ของ Qdrant สั่งค้นหาเวกเตอร์พร้อมกับแนบเงื่อนไขไปในคิวรีเดียว

ซึ่ง Go SDK ของ Qdrant มีฟังก์ชันรองรับเรื่องนี้ได้มีประสิทธิภาพสูงมากครับ ช่วยลด Network Latency ลงไปได้เยอะสุดๆ

ตัวอย่างการเขียน Go ทำ Hybrid Search (Vector Search + Metadata Filter)

แทนที่เราจะเขียนโค้ดทุกอย่างรวมกันใน main() เรามาแบ่งโครงสร้างการทำงานออกเป็น 2 ส่วนหลักๆ กันครับ เพื่อให้โค้ดคลีนและนำไปต่อยอดได้ง่ายขึ้น:

1. ส่วนแปลงข้อความ (Embedding)

2. ส่วนค้นหาและกรองข้อมูล (Hybrid Search)

1. ฟังก์ชันสำหรับแปลงคำถามเป็น Vector (Embedding)

เราจะแยกหน้าที่การคุยกับ OpenAI API ออกมาเป็นฟังก์ชันต่างหาก เพื่อรับข้อความ (Text) และคืนค่ากลับมาเป็นพิกัดเวกเตอร์ ([]float32)

Go

// generateEmbedding รับคำถามและแปลงเป็นพิกัดเวกเตอร์ผ่าน OpenAI
func generateEmbedding(ctx context.Context, client *openai.Client, text string) ([]float32, error) {
	embReq := openai.EmbeddingRequest{
		Input: []string{text},
		Model: openai.SmallEmbedding3Small, // ใช้พิกัด 1,536 มิติ มาตรฐาน
	}
	resp, err := client.CreateEmbeddings(ctx, embReq)
	if err != nil {
		return nil, fmt.Errorf("embedding failed: %w", err)
	}
	return resp.Data[0].Embedding, nil
}

2. ฟังก์ชันสำหรับยิงคิวรี Hybrid Search ไปที่ Qdrant

ฟังก์ชันนี้จะรับพิกัดเวกเตอร์จากข้อ 1 พร้อมกับ "เงื่อนไข" (Metadata) ที่เราต้องการกรอง เช่น แผนกและสถานะเอกสาร เพื่อประกอบร่างเป็นคำสั่งค้นหา

Go

// searchDocuments ค้นหาเอกสารด้วยความหมาย พร้อมกรอง Metadata (Department, Status)
func searchDocuments(ctx context.Context, client *qdrant.Client, queryVector []float32, dept, status string) ([]*qdrant.ScoredPoint, error) {
	searchLimit := uint64(3)
	
	// สร้างสเปกตัวกรองโดยการ Match คีย์เวิร์ดใน Payload
	searchFilters := &qdrant.Filter{
		Must: []*qdrant.Condition{
			qdrant.NewMatchKeyword("department", dept),
			qdrant.NewMatchKeyword("status", status),
		},
	}

	// ยิงคิวรีค้นหาทั้งพิกัดความหมายและกรองเงื่อนไข Metadata ในลูปเดียว
	return client.Query(ctx, &qdrant.QueryPoints{
		CollectionName: "ai_knowledge_base",
		Query:          qdrant.NewQuery(queryVector...),
		Filter:         searchFilters,
		Limit:          &searchLimit,
	})
}

3. ประกอบร่างในฟังก์ชัน main()

พอเราแยกฟังก์ชันออกมาแล้ว โค้ดใน main() ของเราจะอ่านง่ายขึ้นเหมือนอ่านหนังสือเลยครับ เป็นการจำลองลำดับการทำงาน (Workflow) ได้อย่างชัดเจน

Go

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/qdrant/go-client/qdrant"
	"github.com/sashabaranov/go-openai"
)

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	// --- [Setup Clients] ---
	apiKey := os.Getenv("OPENAI_API_KEY")
	if apiKey == "" {
		log.Fatal("Please set your OPENAI_API_KEY environment variable")
	}
	openaiClient := openai.NewClient(apiKey)

	qdrantClient, err := qdrant.NewClient(&qdrant.Config{
		Host: "localhost",
		Port: 6334,
	})
	if err != nil {
		log.Fatalf("Qdrant connection failed: %v", err)
	}
	defer qdrantClient.Close()

	// --- [Define Query & Filters] ---
	userQuery := "ระเบียบการเบิกค่ารักษาพยาบาลมีอะไรบ้าง"
	
	// จำลองค่าที่ดึงมาจาก SQL Database ของระบบหลัก
	targetDepartment := "Human Resources"
	documentStatus := "active"

	// --- [Step 1: Embedding] ---
	queryVector, err := generateEmbedding(ctx, openaiClient, userQuery)
	if err != nil {
		log.Fatalf("Error generating embedding: %v", err)
	}

	// --- [Step 2: Hybrid Search] ---
	searchResp, err := searchDocuments(ctx, qdrantClient, queryVector, targetDepartment, documentStatus)
	if err != nil {
		log.Fatalf("Hybrid Search query failed: %v", err)
	}

	// --- [Step 3: Display Results] ---
	fmt.Printf("🔍 ผลลัพธ์ Hybrid Search สำหรับคำถาม: '%s'\n", userQuery)
	fmt.Printf("📋 [เงื่อนไขระบบ] แผนก: %s | สถานะ: %s\n\n", targetDepartment, documentStatus)
	
	for i, point := range searchResp {
		payloadMap := point.Payload
		
		// ป้องกัน Panic โดยตรวจสอบคีย์ก่อนดึงค่า
		var content, dept, status string
		if val, ok := payloadMap["content"]; ok { content = val.GetStringValue() }
		if val, ok := payloadMap["department"]; ok { dept = val.GetStringValue() }
		if val, ok := payloadMap["status"]; ok { status = val.GetStringValue() }
		
		fmt.Printf("[%d] ความแม่นยำ (Score): %.4f | แผนก: %s | สถานะ: %s\n", i+1, point.Score, dept, status)
		fmt.Printf("   เนื้อหาอ้างอิง: %s\n\n", content)
	}
}

ทำไม Go ถึงตอบโจทย์สถาปัตยกรรม Hybrid Search?

การที่ Backend ต้องวิ่งไปคุยกับ Database ถึงสองที่ (ทั้ง SQL และ Vector) แน่นอนว่าต้องมีเรื่องของความหน่วง (Latency) ตามมาหลอกหลอนแน่ๆ ถ้าเราจัดการกระบวนการทำงานได้ไม่ดีพอ แต่โชคดีที่เราเขียน Go ครับ! เพราะ Go มีของดีที่ช่วยให้เรื่องนี้รับมือได้ง่ายขึ้นมาก:

• Goroutines สำหรับ Concurrent Querying: สมมติว่า Requirement บังคับให้คุณต้องใช้ท่า Two-Stage Query (ดึงข้อมูลแยกคลังกัน) เราก็แค่จับมันรันคู่ขนาน (Parallel) ไปพร้อมกันซะเลยด้วย Goroutines และคุมจังหวะด้วย sync.WaitGroup พอได้ผลลัพธ์จากทั้งสองฝั่งค่อยเอามาทำ Data Intersection กันใน Go ท่านี้ช่วยหั่นเวลาการทำงานลงไปได้เยอะมากเมื่อเทียบกับการต้องมารอ Query ทีละตัว (Sequential)

• ความ Type-Safe ของ Go Struct: เวลาที่เราได้ข้อมูลกลับมาจากฝั่ง Vector Payload (ที่มักจะเป็น JSON หรือ Map) รวมกับข้อมูลแบบ Record จาก SQL Driver เราสามารถจับมันมา Unmarshal เข้าสู่ Go Struct ที่มีการระบุ Type ไว้อย่างชัดเจนตั้งแต่อยู่ใน Memory ทำให้เราจัดระเบียบ Data Transformation ได้อย่างมั่นใจ ช่วยตัดปัญหา Runtime Error ยิบย่อยที่มักจะเจอกับภาษาแบบ Dynamic Typed ไปได้อย่างเด็ดขาดครับ

🎯 ท้าให้ลอง (Daily Mission)

ลองนำโครงสร้างการคิวรีแบบพ่วงฟิลเตอร์ในบทความนี้ ไปต่อยอดกับโปรเจกต์ของคุณดูครับ โดยโจทย์คือ "การดึงเฉพาะเอกสารที่มีอายุไม่เกินระยะเวลาที่กำหนด" (ใช้ตัวกรองประเภทช่วงข้อมูล หรือ Range Filter)

การบ้านชวนคิด: ลองแก้ตัวแปร searchFilters ให้รองรับการเปรียบเทียบข้อมูลตัวเลขหรือ Unix Timestamp (เช่น หาเอกสารที่ฟิลด์ created_at มีค่ามากกว่าเมื่อ 30 วันที่แล้ว) Hint: ลองไปส่อง Document ของ Qdrant Go Client ดูครับว่าการใช้ qdrant.NewRange(...) สำหรับเทียบค่าตัวเลขนั้นต้องเขียนส่งค่าพารามิเตอร์แบบไหน แล้วลองรันคิวรีดูผลลัพธ์ใน Terminal กันได้เลย!

💡 FAQ (คำถามที่พบบ่อย)

การทำ Hybrid Search จำเป็นต้องใช้ Qdrant เสมอไปหรือไม่?

ไม่จำเป็นครับ Vector Database ชั้นนำตัวอื่นๆ เช่น Milvus, Pinecone, Weaviate หรือแม้แต่ pgvector ใน PostgreSQL ก็รองรับการทำ Metadata Filtering เช่นกัน แต่ในซีรีส์นี้เราเลือก Qdrant เพราะมี Go SDK ที่ใช้งานง่าย ประสิทธิภาพสูง และรองรับ Payload Indexing ได้ดีเยี่ยมครับ

ถ้าข้อมูล Metadata (เช่น สิทธิ์การเข้าถึง) มีการเปลี่ยนแปลงบ่อยมาก ควรใช้ท่าไหนดี?

หากสิทธิ์การเข้าถึงเปลี่ยนบ่อยระดับวินาที (Highly Dynamic) การใช้ท่า Two-Stage Query (เช็คสิทธิ์ที่ SQL ก่อน แล้วค่อยเอา ID ไปหา Vector) อาจจะตอบโจทย์เรื่อง Data Consistency มากกว่าครับ แต่ถ้าไม่ได้เปลี่ยนบ่อยมาก ท่า Metadata Pre-filtering ที่เราเขียนในบทความนี้จะให้ Performance ด้านความเร็วที่ดีกว่ามาก (เพียงแค่ต้องเขียนระบบอัปเดต Payload ใน Qdrant ให้ซิงค์กับ SQL เสมอ)

การทำ Payload Indexing กรองข้อมูล ทำให้เปลืองทรัพยากร (Resource) ระบบมากขึ้นไหม?

การสร้าง Index จะใช้พื้นที่ RAM และ Storage เพิ่มขึ้นเล็กน้อยครับ แต่สิ่งที่ได้กลับมาคือความเร็วในการค้นหา (Query Speed) แบบก้าวกระโดด ซึ่งสำหรับการรันบน Production การยอมเสียพื้นที่จัดเก็บเล็กน้อยเพื่อแลกกับ Latency ที่ต่ำลง ถือเป็นการลงทุนที่คุ้มค่ามากครับ

สรุป

ในบทความนี้เราได้เรียนรู้ วิธีผสานการทำงานระหว่าง Relational Database (SQL) และ Vector Database เข้าด้วยกันผ่านเทคนิค Hybrid Search ซึ่งเป็นหัวใจสำคัญในการทำระบบ AI ค้นหาข้อมูลองค์กรให้มีความปลอดภัย ถูกต้องตามสิทธิ์ (Permission) และช่วยดึงเฉพาะข้อมูลที่สถานะพร้อมใช้งานจริงๆ โดยใช้ท่า Metadata Pre-filtering ที่จบครบในคิวรีเดียวผ่าน Go SDK ได้อย่างมีประสิทธิภาพครับ

ในตอนต่อไป (EP.160): ยินดีด้วยครับ! ตอนนี้โครงสร้างภาคทฤษฎีและองค์ประกอบระดับ Advanced ในการพัฒนา AI Integration ของพวกเราพร้อมใช้งานแบบ 100% แล้ว ตอนหน้าจะเป็นการปิดซีซันอย่างยิ่งใหญ่ด้วยการลงมือทำ "Workshop 2: ระบบถาม-ตอบจากเอกสารบริษัทแบบ Internal Tool" เราจะนำทั้ง Gin Web Framework, PDF Extraction, RAG Pipeline และ Hybrid Search มารวมพลังสร้างแอปพลิเคชันสำหรับใช้งานในองค์กรจริงๆ ห้ามพลาดเด็ดขาดครับ Gophers!

ฝากกดติดตามพวกเราได้ที่ Superdev Academy ในทุกช่องทางนะครับ!

• 🔵 Facebook: Superdev Academy Thailand (อัปเดตข่าวสารและบทความใหม่)

• 🎬 YouTube: Superdev Academy Channel (ติวเข้มแบบวิดีโอ)

• 📸 Instagram: @superdevacademy (เกร็ดความรู้สั้นๆ และเบื้องหลังการทำงาน)

• 🎬 TikTok: @superdevacademy (Tips & Tricks ฉบับย่อยง่าย)

• 🌐 Website: superdevacademy.com (คลังบทความและคอร์สเรียนฉบับเต็ม)